DAW Header Libraries
Loading...
Searching...
No Matches
Namespaces | Classes | Concepts | Typedefs | Enumerations | Functions | Variables
daw Namespace Reference

Provides structs for wrapping function pointers and callable objects to facilitate function overloading and safe invocation. More...

Namespaces

namespace  algorithm
 
namespace  container
 
namespace  cxmath
 
namespace  deprecated
 
namespace  ensure
 
namespace  exception
 
namespace  filesystem
 
namespace  func
 
namespace  int_string_sizes
 
namespace  integers
 
namespace  literals
 
namespace  math
 
namespace  memory
 
namespace  metro
 
namespace  min_strings
 
namespace  mixins
 
namespace  monadic_ptr
 
namespace  nparam
 
namespace  parser
 
namespace  pipelines
 
namespace  range
 
namespace  size_literals
 
namespace  string
 
namespace  string_fmt
 
namespace  sv1
 
namespace  sv2
 
namespace  swappable_test
 
namespace  traits
 
namespace  traits_is_sv
 
namespace  tuple
 
namespace  unique_ptr_del
 
namespace  utility
 

Classes

struct  AllocDeleter
 
struct  always_false
 
struct  any_of_t
 A predicate type used in the find based routine to return true when the element is one of the specified characters. More...
 
struct  applier_t
 
class  arg_iterator_t
 
struct  Argument
 
class  Arguments
 
struct  array
 
struct  arrow_proxy
 
struct  back_inserter
 
class  basic_bit_queue
 
struct  basic_bounded_string
 
class  basic_nibble_queue
 
struct  basic_safe_string
 
struct  bidirectional_counting_iterator
 
struct  bind_args_at_fn
 
class  bind_front
 
struct  bit_iterator
 An output iterator that calls supplied bit when operator= is called This is like std::back_insert_iterator. More...
 
struct  bit_queue_source_big_endian
 
struct  bit_queue_source_little_endian
 
struct  bit_stream
 
class  bitset
 
class  bounded_graph_node_t
 
struct  bounded_graph_t
 
struct  bounded_hash_map
 
struct  bounded_hash_map_item_t
 
struct  bounded_hash_map_iterator
 
struct  bounded_hash_set_iterator
 
struct  bounded_hash_set_t
 
struct  bounded_vector_t
 
struct  bounded_vector_t< T, 0 >
 
struct  carray
 
class  CFile
 
struct  char_splitter_t
 
struct  checked_expected_t
 
struct  checked_expected_t< void, ExpectedExceptions... >
 
class  checked_function_t
 
class  checked_iterator_proxy_t
 
struct  chunk_iterator
 
struct  circular_iterator
 
class  clumpy_sparsy
 
struct  clumpy_sparsy_iterator
 
struct  compressed_pair
 
struct  compressed_pair_elem
 
struct  compressed_pair_elem< Tp, Idx, true >
 
struct  const_bounded_hash_map_iterator
 
struct  const_bounded_hash_set_iterator
 
class  const_graph_node_t
 
struct  constant
 
struct  construct_a_t
 Construct a value. If normal ( ) construction does not work try aggregate. More...
 
struct  construct_a_t< daw::use_aggregate_construction< T > >
 
struct  construct_emplace_t
 
struct  construct_for_overwrite_t
 
class  container_data
 
struct  container_deleter
 
struct  container_traits
 
struct  container_traits< std::array< T, N > >
 
struct  container_traits< T[N]>
 
struct  contiguous_view
 
struct  contiguous_view< T, ExplicitConv >
 
class  contract
 
struct  copiable_unique_ptr
 
class  countable_resource_t
 
class  CString
 
struct  deduced_type
 
struct  default_deleter
 
struct  default_deleter< T[]>
 
struct  default_init_tag
 
struct  default_pointer_deleter
 
struct  default_pointer_deleter< T[]>
 
struct  dependent_type
 
struct  discard_t
 Tag type for specifying that the searched for term/item is to be removed from view. More...
 
struct  do_resize_and_overwrite_t
 
struct  dont_clip_to_bounds_t
 
struct  empty_t
 
struct  end_inserter_iterator
 
class  equal_to_last
 
struct  escaped_any_of
 Predicate type that stores the previous element and if it was an '\' escape character, it will return false, otherwise returns true if the current character matches one of the needles. Because this is a stateful predicate, it cannot be reused. More...
 
struct  expander
 
struct  expected_t
 
struct  expected_t< void >
 
struct  extract_from_container_t
 
struct  extract_from_container_t< std::vector< T, Allocator > >
 
struct  find_iterator
 
struct  find_one_element
 
class  find_one_iterator
 
struct  fixed_array
 
struct  fixed_cast
 
struct  fixed_lookup
 A fixed lookup table. Only indices returned by insert or get_existing are defined. A reference does not exist after a copy/move operation but the indices will remain valid In some testing the average distance to actual value was 0.147 when size is double needed items. More...
 
struct  fmt_range
 
struct  fmt_tuple
 
struct  fnv1a_hash_t
 
struct  forward_counting_iterator
 
class  function
 
class  function< MaxSize, Result(FuncArgs...)>
 
struct  function_info
 
struct  function_info< ReturnType(ClassType::*)(Args...) const >
 
struct  function_info< ReturnType(ClassType::*)(Args...) volatile >
 
struct  function_info< ReturnType(ClassType::*)(Args...) volatile const >
 
struct  function_info< ReturnType(ClassType::*)(Args...)>
 
struct  function_iterator
 An output iterator that calls supplied function when operator= is called This is like std::back_insert_iterator. More...
 
struct  function_ref
 
struct  function_ref< Result(Params...)>
 
struct  function_ref< void(Params...)>
 
struct  function_table_t
 
struct  function_traits
 
struct  function_traits< ReturnType(*)(Args...)>
 
struct  function_traits< ReturnType(ClassType::*)(Args...) const >
 
struct  function_traits< ReturnType(ClassType::*)(Args...)>
 
struct  function_view
 
struct  function_view< Result(Args...)>
 
struct  function_view< void(Args...)>
 
struct  function_view_table_storage
 
struct  function_view_table_storage< void, Args... >
 
struct  fwd_pack
 
struct  fwd_pack<>
 
struct  generic_hash_t
 
struct  generic_hash_t< 2 >
 
struct  generic_hash_t< 4 >
 
struct  generic_hash_t< 8 >
 
struct  graph_node_t
 
struct  graph_t
 
struct  has_op_minus
 
struct  has_op_minus< T, U, std::void_t< decltype(std::declval< T >() - std::declval< U >())> >
 
struct  has_reallocate
 
struct  has_reallocate< T, std::void_t< typename T::has_realloc > >
 
class  hash_set_t
 
struct  hash_table
 
struct  hash_table_item_iterator
 
struct  heap_array
 
struct  heap_value
 Heap Value. Access members via operator-> but copy/move constructors operators utilized the pointed to's members This is used on larger classes that are members of other classes but the space requirements is that of a pointer instead of the full size. More...
 
struct  indexed_iterator
 
struct  InputIterator
 
struct  InputRange
 
struct  insert_into_container_t
 
struct  insert_into_container_t< std::vector< T, Allocator > >
 
struct  inserter_iterator
 
struct  integer_range
 
struct  integer_range_iterator
 
struct  invalid_natural_number
 
class  invalid_node_exception
 
struct  iota_iterator
 
struct  iota_range
 
struct  is_ascii_alpha_t
 
struct  is_ascii_alphanum_t
 
struct  is_ascii_digit_t
 
struct  is_ascii_printable_t
 
struct  is_daw_span_t
 
struct  is_daw_span_t< daw::span< T > >
 
struct  is_daw_view_t
 
struct  is_daw_view_t< daw::view< T > >
 
struct  is_iterator
 
struct  is_iterator< T, std::void_t< decltype(std::add_pointer_t< typename std::iterator_traits< T >::value_type >{ })> >
 
struct  is_nothrow_convertible
 
struct  is_system_integral
 
struct  is_tuple2
 
struct  iter_view
 
struct  iterator_pair
 
class  keep_n
 
struct  key_value_t
 
struct  make_signed
 
struct  make_unsigned
 
struct  MallocAlloc
 
struct  md_stdarray
 
struct  MMapAlloc
 
class  move_only
 
class  move_only< void >
 
struct  move_only_base
 
class  mutable_capture
 
struct  natural_t
 
struct  never_null_t
 
class  node_id_t
 
struct  nodiscard_t
 Tag type for specifying that the searched for term/item is not to be removed from view. More...
 
struct  none_of_t
 A predicate type used in the find based routine to return true when the element is none of the specified characters. More...
 
struct  nonesuch
 
class  not_null
 
struct  not_null_value_type
 
struct  numeric_limits
 
struct  observer_ptr
 
class  on_exit_success
 
struct  optional
 
struct  optional< T, std::enable_if_t< not std::is_reference_v< T > > >
 
struct  optional< T, std::enable_if_t< std::is_lvalue_reference_v< T > > >
 
struct  optional_poly
 
struct  ordered_map
 
struct  overload
 
struct  pack_element
 
struct  pack_element< Idx, Pack< Ts... > >
 
struct  pack_list
 
struct  pack_type
 
struct  perfect_hash_table
 
struct  piecewise_factory_late_t
 
struct  piecewise_factory_t
 
struct  pointer_iterator
 
class  poly_value
 
struct  poly_var
 
class  poly_vector_t
 
struct  prop_const_ptr
 
struct  RandomFloat
 
struct  RandomInteger
 
struct  RandomIterator
 
struct  rc_ptr
 
struct  rc_ptr< T[], Deleter >
 
struct  read_only
 
struct  Reference
 
struct  remove_array_ref
 
struct  remove_array_ref< T(&)[N]>
 
struct  repeat_n_char_iterator
 
struct  reverse_iterator
 
struct  ring_adaptor
 
struct  rvalue_to_value
 
struct  rvalue_to_value< T & >
 
struct  rvalue_to_value< T && >
 
struct  sbo_storage
 
class  ScopeGuard
 
struct  set_node_t
 
struct  simple_array
 
struct  simple_array< T, 0 >
 
struct  sized_for_overwrite_t
 
struct  span
 
struct  span< T, std::enable_if_t< not std::is_const_v< T > > >
 
struct  span< T, std::enable_if_t< std::is_const_v< T > > >
 
struct  split_buffer
 
struct  split_it
 
struct  split_it< Iterator, Splitter, std::enable_if_t< not std::is_same_v< char, typename std::iterator_traits< Iterator >::value_type > > >
 
struct  split_it< Iterator, Splitter, std::enable_if_t< std::is_same_v< char, typename std::iterator_traits< Iterator >::value_type > > >
 
struct  splitter_range_t
 
class  static_bitset
 
struct  static_hash_t
 
struct  static_random
 
class  string_split_iterator
 
struct  string_split_range
 
struct  tag_t
 
struct  take_ownership_t
 
struct  take_t
 
struct  template_param
 
struct  template_params
 
struct  template_vals_t
 
struct  terminate_on_read_file_error_t
 
struct  to_lower_ascii_t
 
struct  to_upper_ascii_t
 
class  topological_sorted_iterator
 
class  tuple
 
struct  tuple2
 
struct  tuple2<>
 
struct  tuple2_element
 
struct  tuple2_element< Idx, tuple2< Ts... > >
 
struct  tuple2_size
 
struct  tuple2_size< tuple2< Ts... > >
 
struct  tuple_element
 
struct  tuple_element< Idx, fwd_pack< Ts... > >
 
struct  tuple_size
 
struct  tuple_size< daw::fwd_pack< Ts... > >
 
struct  type_if_else
 
struct  type_if_else< true, IfTrue, IfFalse >
 
struct  undefined_t
 
struct  uninitialized_storage
 
class  union_pair_t
 
struct  unique_array_t
 
struct  unique_ptr
 
struct  unique_ptr< T[], Deleter >
 
class  unique_resource
 
struct  UnorderedWalk
 
struct  unsupported_int_size
 
struct  use_aggregate_construction
 
struct  use_default
 
struct  validated
 
struct  value_init_tag
 
struct  value_ptr
 
struct  Vector
 
struct  vector
 
struct  view
 
struct  virtual_base
 
struct  visit_null_union_pair_exception
 
class  wrap_iter
 
struct  zip_container
 
struct  zip_iterator
 

Concepts

concept  convertible_to
 
concept  same_as
 
concept  same_as_rrcv
 
concept  cvref_of
 
concept  not_me
 
concept  not_cvref_of
 
concept  not_me_d
 
concept  not_decay_of
 
concept  constructible_from
 
concept  Pointers
 
concept  Containers
 
concept  ContiguousContainer
 
concept  ContiguousContainerOf
 
concept  StringLike
 
concept  EnumType
 
concept  UnsignedStd
 
concept  SignedStd
 
concept  IntegralStd
 
concept  IntegralDaw
 
concept  FloatingPointStd
 
concept  FloatingPointDaw
 
concept  AssociativeContainers
 
concept  invocable
 
concept  assignable_from
 Specifies that an expression of the type and value category specified by RHS can be assigned to an lvalue expression whose type is specified by LHS.
 
concept  move_constructible
 Satisfied if T is a reference type, or if it is an object type where an object of that type can be constructed from an rvalue of that type in both direct- and copy-initialization contexts, with the usual semantics.
 
concept  swappable
 Specifies that expressions of the type and value category encoded by T and U are swappable with each other.
 
concept  movable
 Specifies that T is an object type that can be moved (that is, it can be move constructed, move assigned, and lvalues of type T can be swapped).
 
concept  weakly_incrementable
 
concept  invocable_result
 
concept  input_or_output_iterator
 
concept  indirectly_writable
 
concept  derived_from
 
concept  output_iterator
 
concept  input_iterator
 
concept  forward_iterator
 
concept  random_access_iterator
 
concept  BackInsertableContainer
 
concept  boolean_testable
 Specifies the requirements for expressions that are convertible to bool and for which the logical operators have the usual behavior (including short-circuiting), even for two different boolean-testable types.
 
concept  equality_comparable
 Specifies that the comparison operators == and != on T reflects equality: == yields true if and only if the operands are equal.
 
concept  equality_comparable_with
 Specifies that the comparison operators == and != on (possibly mixed) T and U operands yield results consistent with equality. Comparing mixed operands yields results equivalent to comparing the operands converted to their common type.
 
concept  Allocators
 
concept  default_constructible
 
concept  Integer
 
concept  FloatingPoint
 
concept  Arithmetic
 
concept  constructible_to
 
concept  Fn
 
concept  Iterator
 
concept  IsIteratorTag
 
concept  OutputIteratorTag
 
concept  InputIteratorTag
 
concept  InputIterator
 
concept  ForwardIteratorTag
 
concept  ForwardIterator
 
concept  BidirectionalIteratorTag
 
concept  BidirectionalIterator
 
concept  RandomIteratorTag
 
concept  RandomIterator
 
concept  Range
 
concept  InputRange
 
concept  ForwardRange
 
concept  BidirectionalRange
 
concept  RandomRange
 
concept  has_std_formatter_specialization_v
 
concept  ResizeAndOverwriteOperationAlloc
 
concept  ResizeAndOverwriteOperation
 

Typedefs

template<typename T , typename... Ts>
using aligned_storage_for_t = typename impl::aligned_storage< std::max({ sizeof(T), sizeof(Ts)... }), std::max({ alignof(T), alignof(Ts)... })>::type
 
template<std::size_t Size, std::size_t Align = alignof( std::max_align_t )>
using aligned_storage_t = typename impl::aligned_storage< Size, Align >::type
 
template<bool... values>
using all_true = std::bool_constant<(values and ...)>
 
template<bool... values>
using any_true = std::bool_constant<(values or ...)>
 
using bad_variant_access = std::bad_variant_access
 
using bit_queue = basic_bit_queue< uint16_t >
 
using bit_queue_source_native_endian = daw::conditional_t< daw::endian::native==daw::endian::little, bit_queue_source_little_endian, bit_queue_source_big_endian >
 
template<bool B>
using bool_constant = std::bool_constant< B >
 
template<typename T , size_t N>
using bounded_array_t = daw::array< T, N >
 
using bounded_string = basic_bounded_string< char, 100 >
 
template<typename N , typename Invokable , typename TpArgs , typename... Args>
using can_call_test = std::is_invocable< applier_t< Invokable >, decltype(std::tuple_cat(split_args< 0, N::value >(std::forward_as_tuple(DAW_FWD(std::declval< Args >())...)), std::declval< TpArgs >(), split_args< N::value, sizeof...(Args)>(std::forward_as_tuple(DAW_FWD(std::declval< Args >())...))))>
 
template<DAW_CXEVAL_FTYPE F>
using can_constant_evaluate = typename decltype(can_cxeval_impl::can_cxeval< F >())::type
 
template<typename T , typename... Args>
using can_potentially_constant_construct = typename conditional_t<(std::is_default_constructible_v< Args > and ...), can_cxeval_impl::can_potentially_constant_construct_impl< T, Args... >, daw::traits::identity< std::false_type > >::type
 
template<typename T >
using clumpy_sparsy_const_iterator = clumpy_sparsy_iterator< T const >
 
template<typename... Its>
using common_iterator_category_t = daw::remove_cvref_t< decltype(iterator_traits_impl::common_iterator_tag_test_t< std::index_sequence_for< Its... > >::test(std::declval< Its const & >()...))>
 
template<bool B, typename TrueType , typename FalseType >
using conditional_t = typename traits_details::select< B >::template type< TrueType, FalseType >
 
template<typename... Ts>
using conjunction = conjunction_t< Ts... >
 
template<typename... Ts>
using conjunction_t = std::bool_constant< conjunction_v< Ts... > >
 
template<Range R>
using const_iterator_end_t = DAW_TYPEOF(std::cend(std::declval< R const & >()))
 
template<Range R>
using const_iterator_t = DAW_TYPEOF(std::cbegin(std::declval< R const & >()))
 
using cstring = CString< char >
 
template<typename Default , template< typename... > typename Op, typename... Args>
using detected_or = is_detect_details::detector< Default, void, Op, Args... >
 
template<typename Default , template< typename... > typename Op, typename... Args>
using detected_or_t = typename detected_or< Default, Op, Args... >::type
 
template<template< typename... > typename Op, typename... Args>
using detected_t = typename is_detect_details::detector< nonesuch< Op, Args... >, void, Op, Args... >::type
 
template<typename... Ts>
using disjunction = disjunction_t< Ts... >
 
template<typename... Ts>
using disjunction_t = std::bool_constant< disjunction_v< Ts... > >
 
using Empty = empty_t
 
template<typename T , bool B = true>
using enable_copy_assignment = traits_details::delete_copy_assignment_if< not std::is_copy_assignable_v< T > and B >
 
template<typename T , bool B = true>
using enable_copy_constructor = traits_details::delete_copy_constructor_if< not std::is_copy_constructible_v< T > and B >
 
template<typename T , bool B = true>
using enable_default_constructor = traits_details::delete_default_constructor_if< not std::is_default_constructible_v< T > and B >
 
template<bool B, typename T = std::nullptr_t>
using enable_if = std::enable_if< B, T >
 
template<bool B, typename T = std::nullptr_t>
using enable_if_t = std::enable_if_t< B, T >
 
template<typename T , bool B = true>
using enable_move_assignment = traits_details::delete_move_assignment_if< not std::is_move_assignable_v< T > and B >
 
template<typename T , bool B = true>
using enable_move_constructor = traits_details::delete_move_constructor_if< not std::is_move_constructible_v< T > and B >
 
template<typename... Traits>
using enable_when_all_t = enable_if_t< std::conjunction_v< Traits... > >
 
template<bool... B>
using enable_when_t = enable_if_t<(B &&...)>
 
template<size_t N, typename TpArgs , typename... Args>
using enough_args_t = std::bool_constant<((sizeof...(Args)+std::tuple_size_v< TpArgs >) >=N)>
 
template<typename T >
using fn_t = std::add_pointer_t< T >
 
using fnv1a_uint_t = conditional_t< fnv1a_impl::is_64bit_v, std::uint64_t, std::uint32_t >
 
template<typename T >
using fp_t = T *
 
template<typename ResultType , typename... ArgTypes>
using function_pointer_t = typename utility_details::make_function_pointer_impl< ResultType, ArgTypes... >::type
 
template<typename F >
using function_traits_t = typename function_traits< F >::type
 
using genhash_uint_t = std::size_t
 
template<bool Condition, typename IfTrue , typename IfFalse >
using if_else_t = typename type_if_else< Condition, IfTrue, IfFalse >::type
 
template<bool Bool_, typename If_ , typename Then_ >
using if_t = typename std::conditional< Bool_, If_, Then_ >::type
 
template<auto , typename T >
using ignore_one_t = T
 
template<std::size_t N>
using index_constant = std::integral_constant< std::size_t, N >
 
template<std::size_t BitSize>
using intN_t = conditional_t< is_same_size_v< char, BitSize >, char, conditional_t< is_same_size_v< short, BitSize >, short, conditional_t< is_same_size_v< int, BitSize >, int, conditional_t< is_same_size_v< long, BitSize >, long, conditional_t< is_same_size_v< long long, BitSize >, long long, unsupported_int_size< BitSize > > > > > >
 
template<typename T >
using is_arithmetic = std::bool_constant< is_arithmetic_v< T > >
 
template<typename T >
using is_complete_type = std::bool_constant< is_complete_type_v< T > >
 
template<template< typename... > typename Op, typename... Args>
using is_detected = typename is_detect_details::detector< nonesuch< Op, Args... >, void, Op, Args... >::value_t
 
template<typename To , template< typename... > typename Op, typename... Args>
using is_detected_convertible = std::is_convertible< detected_t< Op, Args... >, To >
 
template<typename Expected , template< typename... > typename Op, typename... Args>
using is_detected_exact = std::bool_constant< is_detected_exact_v< Expected, Op, Args... > >
 
template<typename T >
using is_floating_point = std::bool_constant< is_floating_point_v< T > >
 
template<typename T >
using is_integral = std::bool_constant< is_integral_v< T > >
 
template<typename T >
using is_number = std::bool_constant< is_number_v< T > >
 
template<typename T >
using is_reference_wrapper = std::bool_constant< is_reference_wrapper_v< T > >
 
template<typename T , typename U >
using is_same = std::bool_constant< is_same_v< T, U > >
 
template<typename T , std::size_t BitSize>
using is_same_size = std::bool_constant<(bit_count_v< T >==BitSize)>
 
template<typename T , typename U >
using is_same_t = typename std::bool_constant< is_same_v< T, U > >::type
 
template<typename T >
using is_signed = std::bool_constant< is_signed_v< T > >
 
template<template< typename... > typename Primary, typename T >
using is_specialization_of = std::bool_constant< is_specialization_of_v< Primary, T > >
 
template<typename T >
using is_tuple = std::bool_constant< is_tuple_v< T > >
 
template<typename T >
using is_unbounded_array = std::bool_constant< is_unbounded_array_v< T > >
 
template<typename T >
using is_unsigned = std::bool_constant< is_unsigned_v< T > >
 
template<typename It >
using iter_category_t = typename std::iterator_traits< daw::remove_cvref_t< It > >::iterator_category
 
template<typename It >
using iter_const_reference_t = std::common_reference_t< iter_value_t< It > const &&, iter_reference_t< It > >
 
template<typename It >
using iter_difference_t = typename std::iterator_traits< daw::remove_cvref_t< It > >::difference_type
 
template<typename It >
using iter_pointer_t = typename std::iterator_traits< daw::remove_cvref_t< It > >::pointer
 
template<typename It >
using iter_reference_t = typename std::iterator_traits< daw::remove_cvref_t< It > >::reference
 
template<typename T >
using iter_reference_type = iter_reference_t< T >
 
template<typename It >
using iter_value_t = typename std::iterator_traits< daw::remove_cvref_t< It > >::value_type
 
template<typename T >
using iter_value_type = iter_value_t< T >
 
template<typename T >
using iterator_category_t = typename std::iterator_traits< T >::iterator_category
 
template<Range R>
using iterator_end_t = DAW_TYPEOF(std::end(std::declval< R >()))
 
template<Range R>
using iterator_t = DAW_TYPEOF(std::begin(std::declval< R >()))
 
template<typename T >
using make_signed_t = typename make_signed< T >::type
 
template<typename T >
using make_unsigned_t = typename make_unsigned< T >::type
 
template<typename T , std::size_t... Extents>
using md_stdarray_t = typename md_stdarray< T, Extents... >::type
 
template<typename B >
using negation = std::bool_constant< not bool(B::value)>
 
using nibble_queue = basic_nibble_queue< uint8_t >
 
template<typename T >
using non_owning_ptr = T
 
template<typename Pointer >
using not_null_pointer_const_reference_t = std::conditional_t< std::is_pointer_v< Pointer >, Pointer, Pointer const & >
 
template<typename Pointer >
using not_null_pointer_reference_t = std::conditional_t< std::is_pointer_v< Pointer >, Pointer, Pointer & >
 
template<typename Pointer >
using not_null_value_const_reference_t = std::conditional_t< std::is_pointer_v< Pointer >, std::remove_pointer_t< Pointer > const &, not_null_value_type_t< Pointer > const & >
 
template<typename Pointer >
using not_null_value_reference_t = std::conditional_t< std::is_pointer_v< Pointer >, std::remove_pointer_t< Pointer > const &, not_null_value_type_t< Pointer > & >
 
template<typename Pointer >
using not_null_value_type_t = typename not_null_value_type< Pointer >::type
 
template<typename T >
using not_trait = std::bool_constant< not T::value >
 
using nothing = empty_t
 
template<std::size_t Idx, typename Pack >
using pack_element_t = typename pack_element< Idx, Pack >::type
 
template<typename T , typename... Ts>
using pack_index_of = std::integral_constant< std::size_t, pack_index_of_v< T, Ts... > >
 
template<typename Pack >
using pack_size = std::integral_constant< std::size_t, pack_size_v< Pack > >
 
template<size_t N, typename... Ts>
using pack_type_at = traits::nth_type< N, Ts... >
 
template<size_t N, typename... Args>
using pack_type_t = typename pack_type< N, Args... >::type
 
template<typename Pack , typename T >
using param_pack_index_of = std::integral_constant< std::size_t, param_pack_index_of_v< Pack, T > >
 
template<typename ResultType , typename ClassType , typename... ArgTypes>
using pointer_to_const_member_function_t = typename utility_details::make_pointer_to_const_member_function_impl< ResultType, ClassType, ArgTypes... >::type
 
template<typename ResultType , typename ClassType , typename... ArgTypes>
using pointer_to_const_volatile_member_function_t = typename utility_details::make_pointer_to_const_volatile_member_function_impl< ResultType, ClassType, ArgTypes... >::type
 
template<typename ResultType , typename ClassType , typename... ArgTypes>
using pointer_to_member_function_t = typename utility_details::make_pointer_to_member_function_impl< ResultType, ClassType, ArgTypes... >::type
 
template<typename ResultType , typename ClassType , typename... ArgTypes>
using pointer_to_volatile_member_function_t = typename utility_details::make_pointer_to_volatile_member_function_impl< ResultType, ClassType, ArgTypes... >::type
 
template<Range R>
using range_category_t = iter_category_t< iterator_t< R > >
 
template<Range R>
using range_const_reference_t = iter_const_reference_t< iterator_t< R > >
 
template<Range R>
using range_reference_t = iter_reference_t< iterator_t< R > >
 
template<Range R>
using range_value_t = iter_value_t< iterator_t< R > >
 
template<typename T >
using remove_array_ref_t = typename remove_array_ref< T >::type
 
template<typename T >
using remove_cvref_t = std::remove_cv_t< std::remove_reference_t< T > >
 
template<typename T >
using remove_cvrvref_t = std::conditional_t< std::is_rvalue_reference_v< T >, remove_cvref_t< T >, T >
 Make rvalue references remove_cvref_t<T> and alone otherwise.
 
template<typename T >
using remove_rvalue_ref_t = daw::conditional_t< std::is_rvalue_reference_v< T >, daw::remove_cvref_t< T >, T >
 
template<bool B, typename T = std::nullptr_t>
using required = std::enable_if_t< B, T >
 
template<typename T >
using root_type_t = std::remove_cv_t< std::remove_pointer_t< std::decay_t< T > > >
 
template<typename T >
using rvalue_to_value_t = typename rvalue_to_value< T >::type
 
template<typename SanitizeFunction >
using safe_string = basic_safe_string< SanitizeFunction, char >
 
template<typename SanitizeFunction >
using safe_u16string = basic_safe_string< SanitizeFunction, char16_t >
 
template<typename SanitizeFunction >
using safe_u32string = basic_safe_string< SanitizeFunction, char32_t >
 
template<typename SanitizeFunction >
using safe_wstring = basic_safe_string< SanitizeFunction, wchar_t >
 
using String = daw::string::string_details::BasicString< char >
 
template<std::size_t Index, typename... Cases>
using switch_t = pack_element_t< Index, pack_list< Cases... > >
 
template<std::size_t Idx, typename Tuple >
using tuple2_element_t = typename tuple2_element< Idx, Tuple >::type
 
template<size_t N, typename... Args>
using type_n_t = traits::nth_element< N, Args... >
 
using u16bounded_string = basic_bounded_string< char16_t, 100 >
 
using u32bounded_string = basic_bounded_string< char32_t, 100 >
 
template<unsigned Bits>
using UInt = conditional_t<(Bits==8), UInt8, conditional_t<(Bits==16), UInt16, conditional_t<(Bits==32), UInt32, conditional_t<(Bits==64), UInt64, InvalidUIntSize > > > >
 
template<std::size_t BitSize>
using uintN_t = conditional_t< is_same_size_v< char, BitSize >, unsigned char, conditional_t< is_same_size_v< short, BitSize >, unsigned short, conditional_t< is_same_size_v< int, BitSize >, unsigned int, conditional_t< is_same_size_v< long, BitSize >, unsigned long, conditional_t< is_same_size_v< unsigned long long, BitSize >, long long, unsupported_int_size< BitSize > > > > > >
 
template<typename... >
using void_t = void
 
using wbounded_string = basic_bounded_string< wchar_t, 100 >
 
using WString = daw::string::string_details::BasicString< wchar_t >
 

Enumerations

enum class  endian { little = __ORDER_LITTLE_ENDIAN__ , big = __ORDER_BIG_ENDIAN__ , native = __BYTE_ORDER__ }
 
enum class  keep_n_order { ascending , descending }
 
enum class  UInt16 : std::uint16_t
 
enum class  UInt32 : std::uint32_t
 
enum class  UInt64 : std::uint64_t
 
enum class  UInt8 : std::uint8_t
 
enum class  wait_status { found , timeout }
 

Functions

template<typename Iterator , typename Distance >
constexpr void advance (Iterator &it, Distance n)
 Advance iterator n steps.
 
template<typename Distance , typename Iterator >
constexpr void advance_many (Distance d, Iterator &it)
 
template<typename Distance , typename Iterator , typename Iterator2 , typename... Iterators>
constexpr void advance_many (Distance d, Iterator &it, Iterator2 &it2, Iterators &...its)
 
template<typename... Predicates>
requires ( (Fn<Predicates, bool()> or std::convertible_to<Predicates, bool>) and ...)
constexpr bool any_if (Predicates &&...predicates)
 
template<typename... Ts>
constexpr auto any_of_f (Ts &&...needles) noexcept
 
template<typename Container , typename... Args>
constexpr auto append (Container &container, Args &&...args)
 
template<bool use_invoke = true, typename F , typename Tuple >
constexpr decltype(autoapply (F &&f, Tuple &&t)
 
template<typename F , typename... Ts>
constexpr decltype(autoapply (F &&f, tuple< Ts... > &&t)
 
template<typename F , typename... Ts>
constexpr decltype(autoapply (F &&f, tuple< Ts... > &t)
 
template<typename F , typename... Ts>
constexpr decltype(autoapply (F &&f, tuple< Ts... > const &&t)
 
template<typename F , typename... Ts>
constexpr decltype(autoapply (F &&f, tuple< Ts... > const &t)
 
template<typename Func , typename... Ts>
constexpr decltype(autoapply (Func &&func, fwd_pack< Ts... > &&p) noexcept(std::is_nothrow_invocable_v< Func, Ts... >)
 
template<typename Func , typename... Ts>
constexpr decltype(autoapply (tuple2< Ts... > &&tp, Func &&fn)
 
template<typename Func , typename... Ts>
constexpr decltype(autoapply (tuple2< Ts... > &tp, Func &&fn)
 
template<typename Func , typename... Ts>
constexpr decltype(autoapply (tuple2< Ts... > const &&tp, Func &&fn)
 
template<typename Func , typename... Ts>
constexpr decltype(autoapply (tuple2< Ts... > const &tp, Func &&fn)
 
template<typename Arg , typename Callable >
constexpr decltype(autoapply_string (Callable &&callable, daw::string_view str)
 Apply the reified string as the types specified as Arg to the Callable.
 
template<typename... Args, typename Callable >
constexpr decltype(autoapply_string (Callable &&callable, daw::string_view str, daw::string_view delemiter)
 Apply the reified string as the types specified as Args... to the Callable.
 
template<typename... Args, typename Callable , typename Splitter , std::enable_if_t< std::is_invocable_v< Splitter, daw::string_view >, std::nullptr_t > = nullptr>
constexpr decltype(autoapply_string (Callable &&callable, daw::string_view str, Splitter &&splitter)
 Apply the reified string as the types specified as Args... to the Callable.
 
template<typename Callable >
constexpr decltype(autoapply_string2 (Callable &&callable, daw::string_view str, daw::string_view delemiter)
 Apply the reified string as the types deducted from the Callable to the Callable. This may have unexpected results if strings are ot controlled.
 
template<typename Callable , typename Splitter , std::enable_if_t< std::is_invocable_v< Splitter, daw::string_view >, std::nullptr_t > = nullptr>
constexpr decltype(autoapply_string2 (Callable &&callable, daw::string_view str, Splitter &&splitter)
 Apply the reified string as the types deducted from the Callable to the Callable. This may have unexpected results if strings are ot controlled.
 
template<typename Integer , typename MaskBit , typename... MaskBits>
constexpr bool are_set (Integer value, MaskBit mask_bit, MaskBits... mask_bits) noexcept
 
template<typename T , typename Compare = std::equal_to<>, typename U = std::enable_if_t<std::is_array_v<remove_array_ref_t<T>>, remove_array_ref_t<T>>>
constexpr auto array_cmp (T &&lhs, T &&rhs, Compare const &cmp=Compare{ })
 
template<typename From >
auto as_char_array (From &&from) noexcept
 
template<typename T >
constexpr std::add_const_t< T > & as_const (T const &t) noexcept
 
constexpr char AsciiLower (char chr) noexcept
 
template<typename CharType , typename Traits , typename Allocator >
constexpr auto AsciiLower (std::basic_string< CharType, Traits, Allocator > str) noexcept
 
constexpr char AsciiUpper (char chr) noexcept
 
template<typename CharType , typename Traits , typename Allocator >
constexpr auto AsciiUpper (std::basic_string< CharType, Traits, Allocator > str) noexcept
 
template<typename T , typename Rep , typename Period >
wait_status atomic_wait_for (std::atomic< T > const *object, T const &old, std::chrono::duration< Rep, Period > const &rel_time, std::memory_order order=std::memory_order_acquire)
 
template<typename T >
void atomic_wait_if (std::atomic< T > const *object, Fn< bool(T)> auto &&predicate, std::memory_order order=std::memory_order_acquire)
 
template<typename T , typename Rep , typename Period >
wait_status atomic_wait_if_for (std::atomic< T > const *object, Fn< bool(T)> auto &&predicate, std::chrono::duration< Rep, Period > const &rel_time, std::memory_order order=std::memory_order_acquire)
 
template<typename T , typename Clock , typename Duration >
wait_status atomic_wait_if_until (std::atomic< T > const *object, Fn< bool(T)> auto &&predicate, std::chrono::time_point< Clock, Duration > const &timeout_time, std::memory_order order=std::memory_order_acquire)
 
template<typename T , typename Clock , typename Duration >
wait_status atomic_wait_until (std::atomic< T > const *object, T const &old, std::chrono::time_point< Clock, Duration > const &timeout_time, std::memory_order order=std::memory_order_acquire)
 
template<typename T >
void atomic_wait_value_equal (std::atomic< T > const *object, T const &desired_value, std::memory_order order=std::memory_order_acquire)
 
template<typename T , typename Rep , typename Period >
wait_status atomic_wait_value_equal_for (std::atomic< T > const *object, T const &desired_value, std::chrono::duration< Rep, Period > const &rel_time, std::memory_order order=std::memory_order_acquire)
 
template<typename T , typename Clock , typename Duration >
wait_status atomic_wait_value_equal_until (std::atomic< T > const *object, T const &desired_value, std::chrono::time_point< Clock, Duration > const &timeout_time, std::memory_order order=std::memory_order_acquire)
 
template<typename Container >
 back_inserter (Container) -> back_inserter< Container >
 
template<typename... Chars, std::enable_if_t< daw::traits::all_same_v< char, Chars... >, std::nullptr_t > = nullptr>
 basic_bounded_string (Chars...) -> basic_bounded_string< char, sizeof...(Chars)>
 
template<typename CharT , size_t N>
 basic_bounded_string (CharT const (&)[N]) -> basic_bounded_string< CharT, N >
 
template<typename Container >
constexpr auto begin_at (Container &container, size_t n) noexcept(noexcept(std::begin(container))) -> decltype(std::begin(container))
 Take iterator return from begin of a container and return the result of running next with n steps.
 
template<typename Container >
constexpr auto begin_at (Container const &container, size_t n) noexcept(noexcept(std::cbegin(container))) -> decltype(std::cbegin(container))
 Take iterator return from begin of a container and return the result of running next with n steps.
 
template<size_t Runs, char delem = '\n', typename Test , typename... Args>
DAW_ATTRIB_NOINLINE auto bench_n_test (std::string const &title, Test &&test_callable, Args const &...args) noexcept
 
template<size_t Runs, typename Function , typename... Args>
DAW_ATTRIB_NOINLINE std::vector< std::chrono::nanoseconds > bench_n_test_json (Function &&func, Args &&...args) noexcept
 
template<size_t Runs, typename Validator , typename Function , typename... Args>
DAW_ATTRIB_NOINLINE std::vector< std::chrono::nanoseconds > bench_n_test_json_val (Validator &&validator, Function &&func, Args &&...args) noexcept
 
template<size_t Runs, char delem = '\n', typename Test , typename... Args>
DAW_ATTRIB_NOINLINE auto bench_n_test_mbs (std::string const &title, size_t bytes, Test &&test_callable, Args const &...args) noexcept
 
template<size_t Runs, char delem = '\n', typename Validator , typename Function , typename... Args>
DAW_ATTRIB_NOINLINE std::array< double, Runsbench_n_test_mbs2 (std::string const &, size_t, Validator &&validator, Function &&func, Args const &...args) noexcept
 
template<typename Test , typename... Args>
DAW_ATTRIB_NOINLINE auto bench_test (std::string const &title, Test &&test_callable, Args &&...args)
 
template<typename Test , typename... Args>
DAW_ATTRIB_NOINLINE auto bench_test2 (std::string const &title, Test &&test_callable, size_t item_count, Args &&...args)
 
template<typename F >
DAW_ATTRIB_NOINLINE double benchmark (F &&func)
 
template<typename ChildOrder = UnorderedWalk, typename T , typename Function >
void bfs_walk (daw::graph_t< T > &graph, daw::node_id_t start_node_id, Function &&func, ChildOrder ord=ChildOrder{ })
 
template<typename ChildOrder = UnorderedWalk, typename T , typename Function >
void bfs_walk (daw::graph_t< T > const &graph, daw::node_id_t start_node_id, Function &&func, ChildOrder ord=ChildOrder{ })
 
template<typename BiDirectionalIterator >
 bidirectional_counting_iterator (BiDirectionalIterator) -> bidirectional_counting_iterator< BiDirectionalIterator >
 
template<std::size_t N, typename Invokable , typename... Args>
constexpr auto bind_args_at (Invokable &&func, Args &&...args)
 
template<typename Function , typename... Params>
 bind_front (Function, Params...) -> bind_front< Function, Params... >
 
template<typename To , typename From >
To bit_cast (From &&from) noexcept(std::is_nothrow_default_constructible_v< To >)
 
template<typename T = deduced_type, typename Iterator , typename OutputIterator >
void bit_cast_copy (Iterator first, Iterator last, OutputIterator first_out)
 
template<typename T , typename Iterator , typename Function >
void bit_cast_for_each (Iterator first, Iterator last, Function &&func) noexcept(noexcept(func(std::declval< T >())))
 
template<typename T , typename U = deduced_type, typename Iterator , typename OutputIterator , typename Function >
void bit_cast_transform (Iterator first, Iterator last, OutputIterator first_out, Function &&func)
 
template<typename Value >
constexpr std::size_t bitcount (Value value) noexcept
 
template<typename Value , typename... T>
constexpr std::size_t bitcount (Value value, T... values) noexcept
 
template<typename T , typename Allocator = std::allocator<T>, input_iterator InputIterator>
constexpr void block_append_from (vector< T, Allocator > &v, InputIterator first, InputIterator last, std::size_t block_size=512)
 
template<typename T , typename Allocator = std::allocator<T>, input_iterator InputIterator>
constexpr vector< T, Allocator > block_create_from (InputIterator first, InputIterator last, std::size_t block_size=512)
 
template<typename Key , typename Value , typename Hash = std::hash<Key>, size_t N>
 bounded_hash_map (std::pair< Key, Value > const (&&items)[N]) -> bounded_hash_map< Key, Value, N, Hash >
 
template<typename Key , typename Value >
 bounded_hash_map_item_t (Key, Value) -> bounded_hash_map_item_t< Key, Value >
 
constexpr void breakpoint () noexcept
 
template<typename T , typename... Args>
constexpr bool can_extract (std::variant< Args... > &&var) noexcept
 
template<typename T , typename... Args>
constexpr bool can_extract (std::variant< Args... > const &var) noexcept
 
template<typename IntegerDest , typename IntegerSource >
constexpr bool can_fit (IntegerSource const value) noexcept
 
template<typename T , bool AllowDownSignCast = false, typename U >
constexpr decltype(autocast (U &&v)
 
template<typename... ExpectedExceptions, typename Function , typename... Args>
auto checked_from_code (Function func, Args &&...args)
 
template<typename Iterator >
 chunk_iterator (Iterator, std::size_t) -> chunk_iterator< Iterator >
 
template<typename T >
constexpr auto cibegin (T &&container) noexcept
 
template<typename T , size_t N>
constexpr auto cibegin (T const (&container)[N]) noexcept
 
template<typename T , size_t N>
constexpr auto cibegin (T(&container)[N]) noexcept
 
template<typename T >
constexpr auto ciend (T &&container) noexcept
 
template<typename T , size_t N>
constexpr auto ciend (T const (&container)[N]) noexcept
 
template<typename T , size_t N>
constexpr auto ciend (T(&container)[N]) noexcept
 
template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool cmp_equal (T t, U u) noexcept
 
template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool cmp_greater (T t, U u) noexcept
 
template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool cmp_greater_equal (T t, U u) noexcept
 
template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool cmp_less (T t, U u) noexcept
 
template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool cmp_less_equal (T t, U u) noexcept
 
template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool cmp_not_equal (T t, U u) noexcept
 
template<typename T , typename Storage , typename... Args>
T * construct_at (Storage *p, Args &&...args)
 
template<typename T , typename... Args>
constexpr T * construct_at (T *p, Args &&...args)
 
template<typename Destination , typename ExpectedArg >
constexpr decltype(autoconstruct_from (daw::string_view str)
 Contructs an object from the arguments specified in the string using a default delemiter of " ".
 
template<typename Destination , typename... ExpectedArgs>
constexpr decltype(autoconstruct_from (daw::string_view str, daw::string_view delemiter)
 Contructs an object from the arguments specified in the string.
 
template<typename Destination , typename... ExpectedArgs, typename Splitter , std::enable_if_t< std::is_invocable_v< Splitter, daw::string_view >, std::nullptr_t > = nullptr>
constexpr decltype(autoconstruct_from (daw::string_view str, Splitter &&splitter)
 Contructs an object from the arguments specified in the string.
 
template<typename Destination , typename... Args>
constexpr decltype(autoconstruct_from (std::tuple< Args... > &&args) noexcept(noexcept(daw::apply(construct_a< Destination >, std::move(args))))
 
template<typename Destination , typename... Args>
constexpr decltype(autoconstruct_from (std::tuple< Args... > const &args) noexcept(noexcept(daw::apply(construct_a< Destination >, args)))
 
template<typename Container , typename Item >
constexpr bool contains (Container const &container, Item const &item) noexcept
 
template<ContiguousContainer Container>
 contiguous_view (Container &&c) -> contiguous_view< std::remove_reference_t< decltype(*std::data(c))> >
 
template<typename T >
 contiguous_view (T *, std::size_t) -> contiguous_view< T >
 
template<typename T >
 contiguous_view (T *, T *) -> contiguous_view< T >
 
template<typename T , std::size_t N>
 contiguous_view (T(&)[N]) -> contiguous_view< T >
 
DAW_ATTRIB_NOINLINE void contract_failure ()
 
template<typename T >
constexprcopy (T &&value) noexcept(std::is_nothrow_copy_constructible< T >::value)
 
template<typename Iterator , typename OutputIterator >
constexpr OutputIterator copy_n (Iterator first, std::size_t sz, OutputIterator out_it) noexcept
 
template<typename T >
auto copy_ptr_value (T const *const original)
 
template<template< class, class > class Vector, typename T , typename A >
constexpr Vector< T, Acopy_vector (Vector< T, A > const &container, std::size_t num_items)
 
template<typename Key , typename Value >
auto create_hash_table (std::initializer_list< std::pair< Key, Value > > const &values)
 
template<typename T , size_t N>
constexpr void cswap (std::array< T, N > &lhs, std::array< T, N > &rhs) noexcept(std::conjunction_v< std::is_nothrow_move_assignable< T >, std::is_nothrow_move_constructible< T > >)
 
template<typename T >
constexpr void cswap (T &&lhs, T &&rhs) noexcept(std::conjunction_v< std::is_nothrow_move_assignable< T >, std::is_nothrow_move_constructible< T > >)
 
template<typename Iterator1 , typename Iterator2 , typename OutputIterator >
constexpr OutputIterator cxpr_copy (Iterator1 first_in, Iterator2 const last_in, OutputIterator first_out)
 
template<typename Iterator1 , typename Iterator2 , typename OutputIterator >
constexpr OutputIterator cxpr_move (Iterator1 first_in, Iterator2 const last_in, OutputIterator first_out)
 
template<typename Container >
constexpr auto data (Container &&c)
 
template<typename Container >
constexpr auto data_end (Container &&c)
 
 DAW_MAKE_REQ_TRAIT (can_be_bounded_string, daw::bounded_string{ std::declval< T >() })
 
template<class T >
constexpr auto decay_copy (T &&v) noexcept(is_nothrow_convertible_v< T, std::decay_t< T > >) -> std::enable_if_t< std::is_convertible_v< T, std::decay_t< T > >, std::decay_t< T > >
 
void default_contract_failure ()
 
template<typename... >
void deleted ()=delete
 
template<typename T , typename Function , typename ChildOrder = UnorderedWalk>
void dfs_walk (daw::graph_t< T > &graph, daw::node_id_t start_node_id, Function &&func, ChildOrder ord=ChildOrder{ })
 
template<typename T , typename Function , typename ChildOrder = UnorderedWalk>
void dfs_walk (daw::graph_t< T > const &graph, daw::node_id_t start_node_id, Function &&func, ChildOrder ord=ChildOrder{ })
 
template<typename Iterator >
constexpr ptrdiff_t distance (Iterator first, Iterator second) noexcept(noexcept(cpp_17_details::distance_impl(first, second, typename std::iterator_traits< Iterator >::iterator_category{ })))
 Calculate distance between iterators.
 
template<class T >
DAW_ATTRIB_INLINE void do_not_optimize (T const &value)
 
template<typename... Values, std::enable_if_t<(sizeof...(Values) !=1), std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE void do_not_optimize (Values &&...values)
 
template<typename... Args>
void dump (Args &&...args)
 
constexpr bool empty_range (Range auto &&r)
 
template<typename Container >
constexpr auto end_inserter (Container &c)
 
template<typename Container >
 end_inserter_iterator (Container) -> end_inserter_iterator< Container >
 
template<typename T >
constexpr utility_details::EqualToImpl< T > equal_to (T value)
 
template<typename T , typename Allocator >
constexpr vector< T, Allocator >::size_type erase (vector< T, Allocator > &c, auto const &v)
 
template<typename T , typename Allocator >
constexpr vector< T, Allocator >::size_type erase_if (vector< T, Allocator > &c, auto pred)
 
template<typename T , typename U = T>
DAW_ATTRIB_INLINE constexprexchange (T &obj, U &&new_value)
 
template<typename... Ts>
 expander (Ts...) -> expander< Ts... >
 
template<typename Result , typename Function , typename... Args>
expected_t< Resultexpected_from_code (Function &&func, Args &&...args)
 
template<typename Function , typename... Args>
auto expected_from_code (Function &&func, Args &&...args)
 
template<typename Result >
expected_t< Resultexpected_from_exception ()
 
template<typename Result >
expected_t< Resultexpected_from_exception (std::exception_ptr ptr)
 
template<typename Bool >
DAW_ATTRIB_NOINLINE constexpr void expecting (Bool const &expected_result)
 
template<typename T , typename U >
DAW_ATTRIB_NOINLINE constexpr void expecting (T &&expected_result, U &&result)
 
template<typename Exception = std::exception, typename Expression , typename Predicate = benchmark_impl::always_true, std::enable_if_t< std::is_invocable_v< Predicate, Exception >, std::nullptr_t > = nullptr>
DAW_ATTRIB_NOINLINE void expecting_exception (Expression &&expression, Predicate &&pred=Predicate{ })
 
template<typename Bool , typename String >
DAW_ATTRIB_NOINLINE constexpr void expecting_message (Bool &&expected_result, String &&message)
 
template<typename T >
constexpr auto extract_from_container (T &container)
 
template<typename Iterator1 , typename Iterator2 , typename Pred >
std::vector< Iterator1find_all_where (Iterator1 first, Iterator2 const last, Pred predicate)
 
template<typename T , typename Pred >
auto find_all_where (T const &values, Pred predicate)
 
template<typename Iterator , typename Filter >
 find_iterator (Iterator, Filter) -> find_iterator< Iterator, Iterator, Filter >
 
template<typename Iterator , typename IteratorLast , typename Filter >
 find_iterator (Iterator, IteratorLast, Filter) -> find_iterator< Iterator, IteratorLast, Filter >
 
template<typename Iterator , typename IteratorLast , typename Filter >
 find_one_iterator (Iterator, IteratorLast, Filter) -> find_one_iterator< Iterator, IteratorLast, Filter >
 
template<typename Iterator >
 fixed_array (Iterator, std::size_t) -> fixed_array< typename std::iterator_traits< Iterator >::value_type >
 
template<typename... Ts>
 fixed_array (std::in_place_t, Ts...) -> fixed_array< std::common_type_t< Ts... > >
 
template<typename T , typename... Ts>
 fixed_array (std::in_place_type_t< T >, Ts...) -> fixed_array< T >
 
template<typename T >
 fixed_array (std::size_t, T) -> fixed_array< T >
 
template<typename Float , std::enable_if_t< std::is_floating_point_v< Float >, std::nullptr_t > = nullptr>
constexpr Float float_abs (Float f)
 
template<typename T >
constexpr decltype(autofmt_any (T &&v)
 
template<Range R>
 fmt_range (R) -> fmt_range< R >
 
template<Range R, typename CharT >
 fmt_range (R, CharT const *) -> fmt_range< R, CharT >
 
template<Range R, typename CharT >
 fmt_range (R, CharT const *, CharT const *, CharT const *) -> fmt_range< R, CharT >
 
template<typename T >
 fmt_tuple (T) -> fmt_tuple< T >
 
template<typename T , typename CharT >
 fmt_tuple (T, CharT const *) -> fmt_tuple< T, CharT >
 
template<typename T , typename CharT >
 fmt_tuple (T, CharT const *, CharT const *, CharT const *) -> fmt_tuple< T, CharT >
 
template<fnv1a_uint_t N>
constexpr fnv1a_uint_t fnv1a_hash (char const (&ptr)[N]) noexcept
 
constexpr fnv1a_uint_t fnv1a_hash (char const *ptr) noexcept
 
template<typename CharT >
constexpr fnv1a_uint_t fnv1a_hash (CharT const *ptr, std::size_t len) noexcept
 
template<typename CharT , size_t Capacity>
constexpr size_t fnv1a_hash (daw::basic_bounded_string< CharT, Capacity > const &str) noexcept
 
template<typename Integer , std::enable_if_t< std::is_integral_v< Integer >, std::nullptr_t > = nullptr>
constexpr fnv1a_uint_t fnv1a_hash (Integer value) noexcept
 
template<typename StringViewLike , std::enable_if_t< traits_is_sv::is_string_view_like_v< StringViewLike >, std::nullptr_t > = nullptr>
fnv1a_uint_t fnv1a_hash (StringViewLike &&sv)
 
template<typename T >
void force_evaluation (T &value)
 
template<typename T >
void force_evaluation (T const &value)
 
template<typename... Ts>
constexpr tuple< Ts &&... > forward_as_tuple (Ts &&...ts) noexcept
 
template<typename... Ts>
constexpr tuple2< Ts... > forward_as_tuple2 (Ts &&...args)
 
template<typename ForwardIterator >
 forward_counting_iterator (ForwardIterator) -> forward_counting_iterator< ForwardIterator >
 
template<typename... Ts>
constexpr auto forward_nonrvalue_as_tuple (Ts &&...values)
 Forwards arguments but stores rvalues. This allows use to prevent dangling ref's.
 
template<typename... Ts>
constexpr auto forward_nontemp_as_tuple (Ts &&...values)
 
template<std::size_t Idx, typename... Ts>
constexpr decltype(autoforward_nth_pack_element (Ts &&...values)
 
template<typename Function >
 function_iterator (Function) -> function_iterator< Function >
 
template<typename... Ts>
 fwd_pack (Ts &&...) -> fwd_pack< Ts &&... >
 
template<size_t HashBytes = sizeof( genhash_uint_t ), std::size_t N>
constexpr auto generic_hash (char const (&ptr)[N]) noexcept
 
template<size_t HashSize = sizeof( size_t ), typename CharT , size_t Capacity>
constexpr size_t generic_hash (daw::basic_bounded_string< CharT, Capacity > const &str) noexcept
 
template<size_t HashSize = sizeof( size_t ), typename CharT , size_t Capacity>
constexpr size_t generic_hash (daw::basic_bounded_string< CharT, Capacity > sv) noexcept
 
template<size_t HashBytes = sizeof( genhash_uint_t ), typename Iterator , typename IteratorL >
constexpr auto generic_hash (Iterator first, IteratorL const last) noexcept
 
template<size_t HashBytes = sizeof( genhash_uint_t ), typename Iterator >
constexpr auto generic_hash (Iterator first, std::size_t const len) noexcept
 
template<size_t HashBytes = sizeof( genhash_uint_t ), typename StringViewLike , std::enable_if_t< traits_is_sv::is_string_view_like_v< StringViewLike >, std::nullptr_t > = nullptr>
auto generic_hash (StringViewLike const &&sv) noexcept
 
template<size_t HashBytes = sizeof( genhash_uint_t ), typename T , std::enable_if_t< std::is_integral_v< T >, std::nullptr_t > = nullptr>
constexpr auto generic_hash (T const value) noexcept
 
template<std::size_t Idx, typename... Ts>
constexpr decltype(autoget (fwd_pack< Ts... > &&p)
 
template<std::size_t Idx, typename... Ts>
constexpr decltype(autoget (fwd_pack< Ts... > &p)
 
template<std::size_t Idx, typename... Ts>
constexpr decltype(autoget (fwd_pack< Ts... > const &p)
 
template<typename... Args>
constexpr auto get (std::tuple< Args... > &tp, size_t index) noexcept
 
template<typename... Args>
constexpr auto get (std::tuple< Args... > const &tp, size_t index) noexcept
 
template<std::size_t Index, typename Ts >
constexpr Ts && get (tuple2_impl::leaf< Index, Ts, false > &&tp)
 
template<std::size_t Index, typename Ts >
constexpr Tsget (tuple2_impl::leaf< Index, Ts, false > &tp)
 
template<std::size_t Index, typename Ts >
constexpr Ts const && get (tuple2_impl::leaf< Index, Ts, false > const &&tp)
 
template<std::size_t Index, typename Ts >
constexpr Ts constget (tuple2_impl::leaf< Index, Ts, false > const &tp)
 
template<std::size_t Index, typename Ts >
constexpr Ts && get (tuple2_impl::leaf< Index, Ts, true > &&tp)
 
template<std::size_t Index, typename Ts >
constexpr Tsget (tuple2_impl::leaf< Index, Ts, true > &tp)
 
template<std::size_t Index, typename Ts >
constexpr Ts const && get (tuple2_impl::leaf< Index, Ts, true > const &&tp)
 
template<std::size_t Index, typename Ts >
constexpr Ts constget (tuple2_impl::leaf< Index, Ts, true > const &tp)
 
template<std::size_t N, typename... Ts>
constexpr decltype(autoget (tuple< Ts... > &&tp)
 
template<std::size_t N, typename... Ts>
constexpr decltype(autoget (tuple< Ts... > &tp)
 
template<std::size_t N, typename... Ts>
constexpr decltype(autoget (tuple< Ts... > const &tp)
 
template<size_t N, typename... T>
constexpr decltype(autoget (zip_iterator< T... > &zi) noexcept
 
template<size_t N, typename... T>
constexpr decltype(autoget (zip_iterator< T... > const &zi) noexcept
 
template<unsigned N>
constexpr UInt16 get_bit (UInt16 value)
 
template<unsigned N>
constexpr UInt32 get_bit (UInt32 value)
 
template<unsigned N>
constexpr UInt64 get_bit (UInt64 value)
 
template<unsigned N>
constexpr UInt8 get_bit (UInt8 value)
 
template<typename Integer , typename Bit , typename... Bits>
constexpr Integer get_bits (Integer i, Bit b, Bits... bs) noexcept
 get value with all bits but those specified masked out
 
template<typename T , std::size_t Alignment = alignof( T )>
T * get_buffer (std::size_t count) noexcept
 aligned_alloc is not in clang-cl 13 with vs2022
 
template<typename T >
constexprget_left_mask (size_t left_zero_bits) noexcept
 
template<std::size_t Idx, typename Variant >
constexpr decltype(autoget_nt (Variant &&var)
 
template<typename T >
constexprget_right_mask (size_t right_zero_bits) noexcept
 
template<typename OutputIterator >
constexpr OutputIterator hex (char c, OutputIterator it_out) noexcept
 
template<size_t N, typename OutputIterator >
constexpr OutputIterator hex (char const (&str)[N], OutputIterator first_out) noexcept
 
template<typename OutputIterator >
constexpr OutputIterator hex (char const *str, std::size_t len, OutputIterator first_out) noexcept
 
template<typename ForwardIterator1 , typename ForwardIterator2 , typename OutputIterator , std::enable_if_t< std::is_integral_v< typename std::iterator_traits< ForwardIterator1 >::value_type >, std::nullptr_t > = nullptr>
constexpr OutputIterator hex (ForwardIterator1 first_in, ForwardIterator2 const last_in, OutputIterator first_out) noexcept
 
template<typename ForwardIterator1 , typename ForwardIterator2 , typename OutputIterator , std::enable_if_t< not std::is_integral_v< typename std::iterator_traits< ForwardIterator1 >::value_type >, std::nullptr_t > = nullptr>
OutputIterator hex (ForwardIterator1 first_in, ForwardIterator2 const last_in, OutputIterator first_out) noexcept
 
template<typename T , typename OutputIterator , std::enable_if_t< std::is_integral_v< T >, std::nullptr_t > = nullptr>
constexpr OutputIterator hex (T const &val, OutputIterator it_out) noexcept
 
template<typename T , typename OutputIterator , std::enable_if_t< not std::is_integral_v< T >, std::nullptr_t > = nullptr>
OutputIterator hex (T const &val, OutputIterator it_out) noexcept
 
template<typename OutputIterator >
constexpr OutputIterator hex_lc (char c, OutputIterator it_out) noexcept
 
template<typename T >
constexpr auto ibegin (T &&container) noexcept
 
template<typename T , size_t N>
constexpr auto ibegin (T const (&container)[N]) noexcept
 
template<typename T , size_t N>
constexpr auto ibegin (T(&container)[N]) noexcept
 
template<typename T >
constexpr auto iend (T &&container) noexcept
 
template<typename T , size_t N>
constexpr auto iend (T const (&container)[N]) noexcept
 
template<typename T , size_t N>
constexpr auto iend (T(&container)[N]) noexcept
 
template<typename R , typename T , std::enable_if_t< daw::is_integral_v< R > and daw::is_integral_v< T >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool in_range (T t) noexcept
 
template<typename Value , typename LowerBound , typename UpperBound >
constexpr bool in_range (Value &&value, LowerBound &&lower, UpperBound &&upper) noexcept(noexcept(lower<=value &&value< upper))
 Checks if value is in the range [lower, upper)
 
template<typename Container , typename Item >
constexpr auto index_of (Container const &container, Item const &item) noexcept
 
template<typename Iterator >
 InputIterator (Iterator) -> InputIterator< typename std::iterator_traits< Iterator >::value_type >
 
template<typename Container >
 InputRange (Container) -> InputRange< std::remove_reference_t< decltype(*std::begin(std::declval< Container >()))> >
 
template<typename Iterator >
 InputRange (Iterator, Iterator) -> InputRange< typename std::iterator_traits< Iterator >::value_type >
 
template<typename Container , typename Allocator , typename Pointer >
constexpr void insert_into_container (Container &vec, Pointer *buff, Allocator alloc, std::size_t capacity, std::size_t size)
 
template<typename Container >
constexpr auto inserter (Container &c)
 
template<typename F , typename... Args, std::enable_if_t< sizeof...(Args) !=1 or((not is_reference_wrapper_v< Args >) and ...), std::nullptr_t > = nullptr>
constexpr decltype(autoinvoke (F &&f, Args &&...args) noexcept(std::is_nothrow_invocable_v< F, Args... >)
 
template<typename F , typename Arg , typename... Args>
constexpr decltype(autoinvoke (F &&f, std::reference_wrapper< Arg > arg, std::reference_wrapper< Args >... args) noexcept(std::is_nothrow_invocable_v< F, Args... >)
 
 iota_iterator () -> iota_iterator< int >
 
template<typename T , typename... Step>
 iota_iterator (T, Step...) -> iota_iterator< T >
 
 iota_range () -> iota_range< int >
 
template<typename T , typename... EndStep>
 iota_range (T, EndStep...) -> iota_range< T >
 
constexpr bool is_space (char chr) noexcept
 
template<typename R >
constexpr auto iter_last (R &&r)
 
template<typename ForwardIterator1 , typename ForwardIterator2 >
constexpr void iter_swap (ForwardIterator1 lhs, ForwardIterator2 rhs) noexcept(std::conjunction_v< std::is_nothrow_move_assignable< decltype(*lhs)>, std::is_nothrow_move_assignable< decltype(*rhs)> >)
 
template<typename Container >
 iter_view (Container) -> iter_view< typename Container::iterator >
 
template<typename ForwardIterator , typename Last >
 iter_view (ForwardIterator, Last) -> iter_view< ForwardIterator, Last >
 
template<typename T , std::size_t N>
 iter_view (T(&&)[N]) -> iter_view< T * >
 
template<typename T , std::size_t N>
 iter_view (T(&)[N]) -> iter_view< T * >
 
template<typename T = make_array_impl::unspecified_type, typename... Args, std::enable_if_t< not std::is_same_v< T, void >, std::nullptr_t > = nullptr>
constexpr auto make_array (Args &&...args)
 
template<typename T , size_t N>
constexpr auto make_array (T const (&&arry)[N])
 
template<typename Iterator >
constexpr auto make_bit_iterator (Iterator &&it)
 Create a bit_iterator with supplied bit.
 
template<typename BitQueueLSB = bit_queue_source_native_endian, typename InputIteratorF , typename InputIteratorL >
constexpr auto make_bit_stream (InputIteratorF first, InputIteratorL last) noexcept
 
template<typename Key , typename Value , typename Hash = std::hash<Key>, size_t N>
DAW_CONSTEVAL auto make_bounded_hash_map (std::pair< Key, Value > const (&items)[N])
 
template<typename Key , typename Hash = std::hash<Key>, size_t N>
constexpr auto make_bounded_hash_set (Key const (&items)[N]) noexcept
 
template<size_t Capacity = 100, typename CharT , size_t N>
constexpr daw::basic_bounded_string< CharT, Capacitymake_bounded_string (CharT const (&str)[N])
 
template<size_t Capacity = 100, typename Container >
constexpr auto make_bounded_string (Container const &v) noexcept -> basic_bounded_string< typename Container::value_type, Capacity >
 
template<size_t Capacity = 100, typename CharT >
constexpr auto make_bounded_string_it (CharT const *first, CharT const *last) noexcept
 
template<size_t Capacity = 100, typename Iterator , typename CharT = DAW_TYPEOF( *std::declval<Iterator>( ) )>
constexpr auto make_bounded_string_it (Iterator first, Iterator last) noexcept
 
template<typename Function , std::enable_if_t< not std::is_function_v< std::remove_reference_t< Function > >, std::nullptr_t > = nullptr>
constexpr decltype(automake_callable (Function &&func) noexcept
 
template<typename Function , std::enable_if_t< std::is_function_v< Function >, std::nullptr_t > = nullptr>
constexpr auto make_callable (Function *func) noexcept
 
template<typename Result , typename... Exceptions, typename Function >
constexpr checked_function_t< Function, Result, Exceptions... > make_checked_function (Function &&func) noexcept
 
template<typename IteratorFirst , typename IteratorLast >
auto make_checked_iterator_proxy (IteratorFirst first, IteratorLast last, bool CheckIncrement=true, bool CheckDecrement=true, bool CheckDereference=true)
 
template<typename Container >
constexpr auto make_circular_iterator (Container &container) noexcept
 
template<typename Container , typename Iterator >
constexpr auto make_circular_iterator (Container &container, Iterator it) noexcept
 
template<typename T >
constexpr auto make_const_random_iterator (T *const ptr) noexcept
 
template<typename T , typename... Args>
copiable_unique_ptr< T > make_copiable_unique_ptr (Args &&...args) noexcept(std::is_nothrow_constructible_v< T, Args... >)
 
template<typename Value , size_t HashSize = sizeof( size_t ), typename... Keys>
constexpr auto make_fixed_lookup (Keys &&...keys) noexcept
 
template<size_t N>
constexpr auto make_formatter (char const (&str)[N])
 
template<class T , class Tuple >
constexprmake_from_tuple2 (Tuple &&t)
 
template<typename L >
constexpr function_traits_t< Lmake_function (L l) noexcept
 
template<typename ReturnType , typename... Args>
std::function< ReturnType(Args...)> make_function (ReturnType(*p)(Args...))
 
template<typename ReturnType , typename... Args>
std::function< daw::traits::root_type_t< ReturnType >(daw::traits::root_type_t< Args >...)> make_function (ReturnType(*p)(Args...))
 
template<typename ReturnType , typename... Args, typename ClassType >
std::function< ReturnType(Args...)> make_function (ReturnType(ClassType::*p)(Args...))
 
template<typename ReturnType , typename... Args, typename ClassType >
std::function< daw::traits::root_type_t< ReturnType >(daw::traits::root_type_t< Args >...)> make_function (ReturnType(ClassType::*p)(Args...))
 
template<typename ReturnType , typename... Args, class T >
auto make_function (T &&t) -> std::function< decltype(ReturnType(t(std::declval< Args >()...)))(Args...)>
 
template<typename Function >
constexpr auto make_function_iterator (Function &&func)
 Create a function_iterator with supplied function.
 
template<typename R = void, typename Function , typename... Functions>
constexpr function_table_t< R, Function, Functions... > make_function_table (Function fn, Functions... fns)
 
template<typename Arg , typename... Args>
auto make_initializer_list (Arg &&arg, Args &&...args)
 
template<typename Bit , typename... Bits>
constexpr auto make_mask (Bit bit, Bits... bits) noexcept
 
template<typename Iterator >
constexpr std::move_iterator< Iterator > make_move_iterator (Iterator &&i)
 
template<typename T , typename... Args>
auto make_optional_poly (Args &&...args)
 
template<typename OutputStream >
constexpr function_iterator< osi_impl::osi_callable< OutputStream > > make_output_stream_iterator (OutputStream &strm)
 
template<typename Hasher , typename Key , typename Value , size_t N>
constexpr auto make_perfect_hash_table (std::pair< Key, Value > const (&data)[N])
 
template<typename IntType , typename Result = std::vector<IntType>>
Result make_random_data (std::size_t count, IntType a=lowest_value< IntType >, IntType b=max_value< IntType >)
 
template<typename T >
constexpr auto make_random_iterator (T *const ptr) noexcept
 
template<typename Iterator >
constexpr auto make_range (Iterator first, Iterator last) noexcept
 
template<typename T , typename... Args>
DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_single< T > make_rc_ptr (Args &&...args)
 
template<typename T >
DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_array< T > make_rc_ptr (std::size_t size)
 
template<typename T , typename... Args>
DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_single< T > make_rc_ptr_for_overwrite (Args &&...)=delete
 
template<typename T >
DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_array< T > make_rc_ptr_for_overwrite (std::size_t size)
 
template<typename Iterator >
constexpr reverse_iterator< Iterator > make_reverse_iterator (Iterator i)
 
template<typename Graph , typename Compare = daw::graph_alg_impl::NoSort>
auto make_reverse_topological_sorted_range (Graph &&g, Compare c=Compare{ })
 
template<typename L >
constexpr auto make_root_function (L l) noexcept
 
template<typename ReturnType , typename... Args, class T >
auto make_root_function (T &&t) -> std::function< decltype(daw::traits::root_type_t< ReturnType >(t(std::declval< daw::traits::root_type_t< Args > >()...)))(Args...)>
 
template<typename SanitizeFunction , typename charT , typename traits = std::char_traits<charT>, typename Alloc = std::allocator<charT>>
auto make_safe_string (charT const *const unsafe_cstring, SanitizeFunction &&sanitize_function)
 
template<typename SanitizeFunction , typename charT , typename traits , typename Alloc >
auto make_safe_string (std::basic_string< charT, traits, Alloc > unsafe_string, SanitizeFunction &&sanitize_function)
 
template<typename... Args, typename Compare = std::less<>>
auto make_sorted_insert_iterator (std::deque< Args... > &c, Compare compare=Compare{ })
 
template<typename... Args, typename Compare = std::less<>>
decltype(automake_sorted_insert_iterator (std::list< Args... > &c, Compare compare=Compare{ })
 
template<typename... Args, typename Compare = std::less<>>
auto make_sorted_insert_iterator (std::vector< Args... > &c, Compare compare=Compare{ })
 
template<typename CharT , typename Traits , typename Allocator >
constexpr auto make_split_it (std::basic_string< CharT, Traits, Allocator > &str, CharT divider) noexcept
 
template<typename String , typename Splitter , daw::required< impl::is_splitter_v< Splitter, String > > = nullptr>
constexpr auto make_split_it (String &sv, Splitter &&splitter) noexcept
 
template<typename ReturnType , typename... Args, typename ClassType >
std::function< ReturnType(Args...)> make_std_function (ReturnType(ClassType::*p)(Args...))
 
template<typename... Ts>
std::array< std::string, sizeof...(Ts)> make_string_array (Ts &&...t)
 
template<typename Graph , typename Compare = daw::graph_alg_impl::NoSort>
auto make_topological_sorted_range (Graph &&g, Compare c=Compare{ })
 
template<typename... Ts>
constexpr tuple< make_tuple_details::unwrap_decay_t< Ts >... > make_tuple (Ts &&...args)
 
template<typename T , typename... Args>
DAW_CPP20_CX_ALLOC auto make_unique (Args &&...args) -> std::enable_if_t< not std::is_array_v< T >, unique_ptr< T > >
 
template<typename T >
DAW_CPP20_CX_ALLOC auto make_unique (std::size_t count) -> std::enable_if_t< std::is_array_v< T >, unique_ptr< T > >
 
template<typename T , typename... Elements>
DAW_CPP20_CX_ALLOC auto make_unique_array (Elements &&...elements) -> std::enable_if_t< std::is_array_v< T >, unique_ptr< T > >
 
template<typename T >
DAW_CPP20_CX_ALLOC auto make_unique_for_overwrite () -> std::enable_if_t< not std::is_array_v< T >, unique_ptr< T > >
 
template<typename Function >
constexpr auto make_void_function (Function &&func) noexcept(noexcept(traits_details::void_function< Function >(DAW_FWD(func))))
 
template<typename... Containers>
zip_container< Containers... > make_zipcontainer (Containers &&...args)
 
template<typename T >
constexprmask_lsb (size_t bit_count) noexcept
 
template<typename T >
constexprmask_msb (size_t bit_count) noexcept
 
template<typename T , typename... Ts>
constexpr auto() max (T const &val1, Ts const &...vs) noexcept
 
template<typename T , typename Compare = math_impl::less>
constexpr decltype(automax_comp (T &&lhs, T &&rhs, Compare &&comp=Compare{ })
 
template<typename T , typename... Ts>
constexpr auto() min (T const &val1, Ts const &...vs) noexcept
 
template<typename T , typename Compare = math_impl::less>
constexpr decltype(automin_comp (T &&lhs, T &&rhs, Compare &&comp=Compare{ })
 
template<typename T >
constexpr daw::traits::remove_reference_t< T > && move (T &&value) noexcept
 Convert a value to an rvalue.
 
template<typename Iterator , typename OutputIterator >
constexpr OutputIterator move_n (Iterator first, std::size_t sz, OutputIterator out_it) noexcept
 
template<typename T >
 move_only (T) -> move_only< T >
 
template<typename T , typename Compare = daw::graph_alg_impl::NoSort>
void mst (daw::graph_t< T > &graph, Compare=Compare{ })
 
template<typename T >
 mutable_capture (T) -> mutable_capture< T >
 
template<typename Integer , typename... Ts, typename T >
constexpr Integer narrow_cast (T value)
 
template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>
constexprnetwork_to_host_endian (T value) noexcept
 
template<typename Iterator >
constexpr Iterator next (Iterator it, ptrdiff_t n=1) noexcept
 Move iterator forward n steps, if n < 0 it is only defined for types that are Bidirectional.
 
template<typename... Ts>
constexpr auto none_of_f (Ts &&...needles) noexcept
 
template<typename Function >
constexpr utility_details::NotImpl< FunctionNot (Function func)
 
template<typename Function >
constexpr auto not_fn ()
 
template<typename Function >
constexpr auto not_fn (Function &&func)
 
template<typename Pointer >
 not_null (never_null_t, not_null< Pointer >) -> not_null< Pointer >
 
template<typename Pointer >
 not_null (never_null_t, Pointer) -> not_null< Pointer >
 
template<typename Pointer >
 not_null (not_null< Pointer >) -> not_null< Pointer >
 
template<typename Pointer >
 not_null (Pointer) -> not_null< Pointer >
 
template<typename Bool , typename... Bools>
DAW_ATTRIB_INLINE constexpr bool nsc_and (Bool lhs, Bools... rhs) noexcept
 Explicitly do a non-short circuiting logical and with bitwise and.
 
template<typename Bool , typename... Bools>
DAW_ATTRIB_INLINE constexpr bool nsc_or (Bool lhs, Bools... rhs) noexcept
 Explicitly do a non-short circuiting logical or with bitwise or.
 
template<std::size_t Idx, typename... Ts>
constexpr auto nth_pack_element (Ts &&...values)
 
template<typename P >
 observer_ptr (P *) -> observer_ptr< P >
 
template<typename Obj , typename T >
constexpr std::size_t offset_of (T Obj::*Mem)
 
template<typename Handler >
 on_exit_success (Handler) -> on_exit_success< Handler >
 
template<typename FunctionType >
DAW_ATTRIB_INLINE constexpr ScopeGuard< FunctionTypeon_scope_exit (FunctionType f) noexcept(std::is_nothrow_move_constructible_v< FunctionType >)
 
constexpr bool operator! (UInt16 value)
 
constexpr bool operator! (UInt32 value)
 
constexpr bool operator! (UInt64 value)
 
constexpr bool operator! (UInt8 value)
 
template<typename T , typename U , size_t N>
constexpr bool operator!= (array< T, N > const &lhs, array< U, N > const &rhs)
 
template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool operator!= (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept
 
template<typename Key , typename Value >
constexpr bool operator!= (bounded_hash_map_iterator< Key, Value > const &lhs, bounded_hash_map_iterator< Key, Value > const &rhs)
 
template<typename Key , typename Value >
constexpr bool operator!= (bounded_hash_map_iterator< Key, Value > const &lhs, const_bounded_hash_map_iterator< Key, Value > const &rhs)
 
template<typename Key >
constexpr bool operator!= (bounded_hash_set_iterator< Key > const &lhs, bounded_hash_set_iterator< Key > const &rhs) noexcept
 
template<typename Key >
constexpr bool operator!= (bounded_hash_set_iterator< Key > const &lhs, const_bounded_hash_set_iterator< Key > const &rhs) noexcept
 
template<typename CharT , size_t Capacity, size_t N>
constexpr bool operator!= (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename Key , typename Value >
constexpr bool operator!= (const_bounded_hash_map_iterator< Key, Value > const &lhs, bounded_hash_map_iterator< Key, Value > const &rhs)
 
template<typename Key , typename Value >
constexpr bool operator!= (const_bounded_hash_map_iterator< Key, Value > const &lhs, const_bounded_hash_map_iterator< Key, Value > const &rhs)
 
template<typename Key >
constexpr bool operator!= (const_bounded_hash_set_iterator< Key > const &lhs, bounded_hash_set_iterator< Key > const &rhs) noexcept
 
template<typename Key >
constexpr bool operator!= (const_bounded_hash_set_iterator< Key > const &lhs, const_bounded_hash_set_iterator< Key > const &rhs) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator!= (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator!= (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept
 
template<typename CharT , size_t Capacity, size_t N>
constexpr bool operator!= (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept
 
template<typename CharT , size_t Capacity>
constexpr bool operator!= (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept
 
template<typename CharT , size_t Capacity>
bool operator!= (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept
 
template<typename CharT , size_t Capacity>
constexpr bool operator!= (daw::basic_bounded_string< CharT, Capacity > const &lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept
 
template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool operator!= (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept
 
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool operator!= (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept
 
template<typename T >
bool operator!= (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs)
 
template<typename CharT , size_t Capacity>
constexpr bool operator!= (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T , typename U >
bool operator!= (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs)
 
template<typename T , typename U >
bool operator!= (heap_value< T > const &lhs, heap_value< U > const &rhs)
 
template<typename T , typename U , std::enable_if_t< not std::is_convertible_v< T, U >, std::nullptr_t > = nullptr>
constexpr bool operator!= (indexed_iterator< T > const &, indexed_iterator< U > const &) noexcept
 
template<typename T >
constexpr bool operator!= (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator!= (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept
 
constexpr bool operator!= (node_id_t const &lhs, node_id_t const &rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator!= (optional< T > const &lhs, optional< U > const &rhs)
 
template<typename T >
constexpr bool operator!= (optional< T > const &opt, std::nullopt_t) noexcept
 
template<typename T , typename U >
constexpr bool operator!= (optional< T > const &opt, U const &value)
 
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool operator!= (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept
 
template<typename T >
bool operator!= (Reference< T > const &lhs, Reference< T > const &rhs)
 
template<typename CharT >
constexpr bool operator!= (repeat_n_char_iterator< CharT > const &lhs, repeat_n_char_iterator< CharT > const &rhs) noexcept
 
template<typename Iterator1 , typename Iterator2 >
constexpr bool operator!= (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs)
 
template<typename Iterator >
constexpr bool operator!= (splitter_range_t< Iterator > const &lhs, splitter_range_t< Iterator > const &rhs) noexcept
 
template<typename CharT , size_t Capacity>
constexpr bool operator!= (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T >
constexpr bool operator!= (std::nullopt_t, optional< T > const &opt) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator!= (std::nullptr_t, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
 
constexpr bool operator!= (std::uint16_t lhs, UInt16 rhs) noexcept
 
constexpr bool operator!= (std::uint32_t lhs, UInt32 rhs) noexcept
 
constexpr bool operator!= (std::uint64_t lhs, UInt64 rhs) noexcept
 
constexpr bool operator!= (std::uint8_t lhs, UInt8 rhs) noexcept
 
template<typename CharT >
constexpr bool operator!= (string_split_iterator< CharT > const &lhs, string_split_iterator< CharT > const &rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator!= (T const &value, optional< U > const &opt)
 
template<typename CharT , size_t Capacity>
constexpr bool operator!= (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
constexpr bool operator!= (UInt16 lhs, std::uint16_t rhs) noexcept
 
constexpr bool operator!= (UInt32 lhs, std::uint32_t rhs) noexcept
 
constexpr bool operator!= (UInt64 lhs, std::uint64_t rhs) noexcept
 
constexpr bool operator!= (UInt8 lhs, std::uint8_t rhs) noexcept
 
template<typename T , typename D0 , typename D1 = D0>
constexpr bool operator!= (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept
 
template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_inequality< T, U >, std::nullptr_t > = nullptr>
constexpr bool operator!= (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs != *rhs))
 
constexpr UInt16 operator""_u16 (unsigned long long value)
 
constexpr UInt32 operator""_u32 (unsigned long long value)
 
constexpr UInt64 operator""_u64 (unsigned long long value)
 
constexpr UInt8 operator""_u8 (unsigned long long value)
 
constexpr UInt16 operator& (std::uint16_t lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator& (std::uint32_t lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator& (std::uint64_t lhs, UInt64 rhs) noexcept
 
constexpr UInt8 operator& (std::uint8_t lhs, UInt8 rhs) noexcept
 
constexpr UInt16 operator& (UInt16 lhs, std::uint16_t rhs) noexcept
 
constexpr UInt16 operator& (UInt16 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator& (UInt16 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator& (UInt16 lhs, UInt64 rhs) noexcept
 
constexpr UInt16 operator& (UInt16 lhs, UInt8 rhs) noexcept
 
constexpr UInt32 operator& (UInt32 lhs, std::uint32_t rhs) noexcept
 
constexpr UInt32 operator& (UInt32 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator& (UInt32 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator& (UInt32 lhs, UInt64 rhs) noexcept
 
constexpr UInt32 operator& (UInt32 lhs, UInt8 rhs) noexcept
 
constexpr UInt64 operator& (UInt64 lhs, std::uint64_t rhs) noexcept
 
constexpr UInt64 operator& (UInt64 lhs, UInt16 rhs) noexcept
 
constexpr UInt64 operator& (UInt64 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator& (UInt64 lhs, UInt64 rhs) noexcept
 
constexpr UInt64 operator& (UInt64 lhs, UInt8 rhs) noexcept
 
constexpr UInt8 operator& (UInt8 lhs, std::uint8_t rhs) noexcept
 
constexpr UInt32 operator& (UInt8 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator& (UInt8 lhs, UInt64 rhs) noexcept
 
constexpr UInt8 operator& (UInt8 lhs, UInt8 rhs) noexcept
 
constexpr UInt16operator&= (UInt16 &lhs, std::uint16_t rhs) noexcept
 
constexpr UInt16operator&= (UInt16 &lhs, UInt16 rhs) noexcept
 
constexpr UInt16operator&= (UInt16 &lhs, UInt8 rhs) noexcept
 
constexpr UInt32operator&= (UInt32 &lhs, std::uint32_t rhs) noexcept
 
constexpr UInt32operator&= (UInt32 &lhs, UInt16 rhs) noexcept
 
constexpr UInt32operator&= (UInt32 &lhs, UInt32 rhs) noexcept
 
constexpr UInt32operator&= (UInt32 &lhs, UInt8 rhs) noexcept
 
constexpr UInt64operator&= (UInt64 &lhs, std::uint64_t rhs) noexcept
 
constexpr UInt64operator&= (UInt64 &lhs, UInt16 rhs) noexcept
 
constexpr UInt64operator&= (UInt64 &lhs, UInt32 rhs) noexcept
 
constexpr UInt64operator&= (UInt64 &lhs, UInt64 rhs) noexcept
 
constexpr UInt64operator&= (UInt64 &lhs, UInt8 rhs) noexcept
 
constexpr UInt8operator&= (UInt8 &lhs, std::uint8_t rhs) noexcept
 
constexpr UInt8operator&= (UInt8 &lhs, UInt8 rhs) noexcept
 
constexpr UInt16 operator* (std::uint16_t lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator* (std::uint32_t lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator* (std::uint32_t lhs, UInt32 rhs) noexcept
 
constexpr UInt32 operator* (std::uint32_t lhs, UInt8 rhs) noexcept
 
constexpr UInt64 operator* (std::uint64_t lhs, UInt64 rhs) noexcept
 
constexpr UInt8 operator* (std::uint8_t lhs, UInt64 rhs) noexcept
 
constexpr UInt16 operator* (UInt16 lhs, std::uint16_t rhs) noexcept
 
constexpr UInt16 operator* (UInt16 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator* (UInt16 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator* (UInt16 lhs, UInt64 rhs) noexcept
 
constexpr UInt16 operator* (UInt16 lhs, UInt8 rhs) noexcept
 
constexpr UInt32 operator* (UInt32 lhs, std::uint32_t rhs) noexcept
 
constexpr UInt32 operator* (UInt32 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator* (UInt32 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator* (UInt32 lhs, UInt64 rhs) noexcept
 
constexpr UInt32 operator* (UInt32 lhs, UInt8 rhs) noexcept
 
constexpr UInt64 operator* (UInt64 lhs, std::uint64_t rhs) noexcept
 
constexpr UInt64 operator* (UInt64 lhs, UInt16 rhs) noexcept
 
constexpr UInt64 operator* (UInt64 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator* (UInt64 lhs, UInt64 rhs) noexcept
 
constexpr UInt64 operator* (UInt64 lhs, UInt8 rhs) noexcept
 
constexpr UInt16 operator* (UInt8 lhs, std::uint16_t rhs) noexcept
 
constexpr UInt8 operator* (UInt8 lhs, std::uint64_t rhs) noexcept
 
constexpr UInt16 operator* (UInt8 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator* (UInt8 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator* (UInt8 lhs, UInt64 rhs) noexcept
 
constexpr UInt8 operator* (UInt8 lhs, UInt8 rhs) noexcept
 
constexpr std::uint16_t & operator*= (std::uint16_t &lhs, UInt16 rhs) noexcept
 
constexpr std::uint16_t & operator*= (std::uint16_t &lhs, UInt8 rhs) noexcept
 
constexpr std::uint32_t & operator*= (std::uint32_t &lhs, UInt16 rhs) noexcept
 
constexpr std::uint32_t & operator*= (std::uint32_t &lhs, UInt32 rhs) noexcept
 
constexpr std::uint32_t & operator*= (std::uint32_t &lhs, UInt8 rhs) noexcept
 
constexpr std::uint64_t & operator*= (std::uint64_t &lhs, UInt64 rhs) noexcept
 
constexpr std::uint8_t & operator*= (std::uint8_t &lhs, UInt8 rhs) noexcept
 
constexpr UInt16operator*= (UInt16 &lhs, std::uint16_t rhs) noexcept
 
constexpr UInt16operator*= (UInt16 &lhs, UInt16 rhs) noexcept
 
constexpr UInt16operator*= (UInt16 &lhs, UInt8 rhs) noexcept
 
constexpr UInt32operator*= (UInt32 &lhs, std::uint32_t rhs) noexcept
 
constexpr UInt32operator*= (UInt32 &lhs, UInt16 rhs) noexcept
 
constexpr UInt32operator*= (UInt32 &lhs, UInt32 rhs) noexcept
 
constexpr UInt32operator*= (UInt32 &lhs, UInt8 rhs) noexcept
 
constexpr UInt64operator*= (UInt64 &lhs, std::uint64_t rhs) noexcept
 
constexpr UInt64operator*= (UInt64 &lhs, UInt16 rhs) noexcept
 
constexpr UInt64operator*= (UInt64 &lhs, UInt32 rhs) noexcept
 
constexpr UInt64operator*= (UInt64 &lhs, UInt64 rhs) noexcept
 
constexpr UInt64operator*= (UInt64 &lhs, UInt8 rhs) noexcept
 
constexpr UInt8operator*= (UInt8 &lhs, std::uint8_t rhs) noexcept
 
constexpr UInt8operator*= (UInt8 &lhs, UInt8 rhs) noexcept
 
template<typename CharT , size_t Capacity>
auto operator+ (CharT const *lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs)
 
template<typename CharT , size_t N, size_t Capacity>
auto operator+ (CharT(&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs)
 
template<typename T >
not_null< T > operator+ (const not_null< T > &, std::ptrdiff_t)=delete
 
template<typename CharT , size_t Capacity>
auto operator+ (daw::basic_bounded_string< CharT, Capacity > lhs, CharT const *rhs)
 
template<typename CharT , size_t Capacity, size_t N>
auto operator+ (daw::basic_bounded_string< CharT, Capacity > lhs, CharT(&rhs)[N])
 
template<typename CharT , size_t Capacity, typename Allocator >
auto operator+ (daw::basic_bounded_string< CharT, Capacity > lhs, std::basic_string< CharT, Allocator > &&rhs)
 
template<typename CharT , size_t Capacity, typename Allocator >
auto operator+ (daw::basic_bounded_string< CharT, Capacity > lhs, std::basic_string< CharT, Allocator > const &rhs)
 
template<typename CharT , size_t Capacity, typename Allocator >
auto operator+ (std::basic_string< CharT, Allocator > lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs)
 Appending.
 
template<typename Iterator1 , typename Tag >
constexpr wrap_iter< Iterator1, Tagoperator+ (std::ptrdiff_t n, wrap_iter< Iterator1, Tag > x) noexcept
 
template<typename T >
not_null< T > operator+ (std::ptrdiff_t, const not_null< T > &)=delete
 
constexpr UInt16 operator+ (std::uint16_t lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator+ (std::uint32_t lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator+ (std::uint32_t lhs, UInt32 rhs) noexcept
 
constexpr UInt32 operator+ (std::uint32_t lhs, UInt8 rhs) noexcept
 
constexpr UInt64 operator+ (std::uint64_t lhs, UInt64 rhs) noexcept
 
constexpr UInt8 operator+ (std::uint8_t lhs, UInt8 rhs) noexcept
 
template<typename Iterator >
constexpr reverse_iterator< Iterator > operator+ (typename reverse_iterator< Iterator >::difference_type n, reverse_iterator< Iterator > const &it)
 
constexpr UInt16 operator+ (UInt16 lhs, std::uint16_t rhs) noexcept
 
constexpr UInt32 operator+ (UInt16 lhs, std::uint32_t rhs) noexcept
 
constexpr UInt16 operator+ (UInt16 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator+ (UInt16 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator+ (UInt16 lhs, UInt64 rhs) noexcept
 
constexpr UInt16 operator+ (UInt16 lhs, UInt8 rhs) noexcept
 
constexpr UInt16 operator+ (UInt16 value)
 
constexpr UInt32 operator+ (UInt32 lhs, std::uint32_t rhs) noexcept
 
constexpr UInt32 operator+ (UInt32 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator+ (UInt32 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator+ (UInt32 lhs, UInt64 rhs) noexcept
 
constexpr UInt32 operator+ (UInt32 lhs, UInt8 rhs) noexcept
 
constexpr UInt32 operator+ (UInt32 value)
 
constexpr UInt64 operator+ (UInt64 lhs, std::uint64_t rhs) noexcept
 
constexpr UInt64 operator+ (UInt64 lhs, UInt16 rhs) noexcept
 
constexpr UInt64 operator+ (UInt64 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator+ (UInt64 lhs, UInt64 rhs) noexcept
 
constexpr UInt64 operator+ (UInt64 lhs, UInt8 rhs) noexcept
 
constexpr UInt64 operator+ (UInt64 value)
 
constexpr UInt16 operator+ (UInt8 lhs, std::uint16_t rhs) noexcept
 
constexpr UInt32 operator+ (UInt8 lhs, std::uint32_t rhs) noexcept
 
constexpr UInt8 operator+ (UInt8 lhs, std::uint8_t rhs) noexcept
 
constexpr UInt16 operator+ (UInt8 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator+ (UInt8 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator+ (UInt8 lhs, UInt64 rhs) noexcept
 
constexpr UInt8 operator+ (UInt8 lhs, UInt8 rhs) noexcept
 
constexpr UInt8 operator+ (UInt8 value)
 
constexpr UInt16operator++ (UInt16 &value)
 
constexpr UInt16 operator++ (UInt16 &value, int)
 
constexpr UInt32operator++ (UInt32 &value)
 
constexpr UInt32 operator++ (UInt32 &value, int)
 
constexpr UInt64operator++ (UInt64 &value)
 
constexpr UInt64 operator++ (UInt64 &value, int)
 
constexpr UInt8operator++ (UInt8 &value)
 
constexpr UInt8 operator++ (UInt8 &value, int)
 
constexpr std::uint16_t & operator+= (std::uint16_t &lhs, UInt16 rhs) noexcept
 
constexpr std::uint16_t & operator+= (std::uint16_t &lhs, UInt8 rhs) noexcept
 
constexpr std::uint32_t & operator+= (std::uint32_t &lhs, UInt16 rhs) noexcept
 
constexpr std::uint32_t & operator+= (std::uint32_t &lhs, UInt32 rhs) noexcept
 
constexpr std::uint32_t & operator+= (std::uint32_t &lhs, UInt8 rhs) noexcept
 
constexpr std::uint64_t & operator+= (std::uint64_t &lhs, UInt64 rhs) noexcept
 
constexpr std::uint8_t & operator+= (std::uint8_t &lhs, UInt8 rhs) noexcept
 
constexpr UInt16operator+= (UInt16 &lhs, std::uint16_t rhs) noexcept
 
constexpr UInt16operator+= (UInt16 &lhs, UInt16 rhs) noexcept
 
constexpr UInt16operator+= (UInt16 &lhs, UInt8 rhs) noexcept
 
constexpr UInt32operator+= (UInt32 &lhs, std::uint32_t rhs) noexcept
 
constexpr UInt32operator+= (UInt32 &lhs, UInt16 rhs) noexcept
 
constexpr UInt32operator+= (UInt32 &lhs, UInt32 rhs) noexcept
 
constexpr UInt32operator+= (UInt32 &lhs, UInt8 rhs) noexcept
 
constexpr UInt64operator+= (UInt64 &lhs, std::uint64_t rhs) noexcept
 
constexpr UInt64operator+= (UInt64 &lhs, UInt16 rhs) noexcept
 
constexpr UInt64operator+= (UInt64 &lhs, UInt32 rhs) noexcept
 
constexpr UInt64operator+= (UInt64 &lhs, UInt64 rhs) noexcept
 
constexpr UInt64operator+= (UInt64 &lhs, UInt8 rhs) noexcept
 
constexpr UInt8operator+= (UInt8 &lhs, std::uint8_t rhs) noexcept
 
constexpr UInt8operator+= (UInt8 &lhs, UInt8 rhs) noexcept
 
template<typename T , typename U >
std::ptrdiff_t operator- (const not_null< T > &, const not_null< U > &)=delete
 
template<typename T >
not_null< T > operator- (const not_null< T > &, std::ptrdiff_t)=delete
 
template<class Iterator1 , class Iterator2 >
constexpr auto operator- (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs) -> decltype(rhs.base() - lhs.base())
 
constexpr UInt16 operator- (std::uint16_t lhs, UInt16 rhs) noexcept
 
constexpr UInt16 operator- (std::uint16_t lhs, UInt8 rhs) noexcept
 
constexpr UInt32 operator- (std::uint32_t lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator- (std::uint32_t lhs, UInt32 rhs) noexcept
 
constexpr UInt32 operator- (std::uint32_t lhs, UInt8 rhs) noexcept
 
constexpr UInt64 operator- (std::uint64_t lhs, UInt64 rhs) noexcept
 
constexpr UInt8 operator- (std::uint8_t lhs, UInt8 rhs) noexcept
 
template<typename Iterator >
constexpr reverse_iterator< Iterator > operator- (typename reverse_iterator< Iterator >::difference_type n, reverse_iterator< Iterator > const &it)
 
constexpr UInt16 operator- (UInt16 lhs, std::uint16_t rhs) noexcept
 
constexpr UInt16 operator- (UInt16 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator- (UInt16 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator- (UInt16 lhs, UInt64 rhs) noexcept
 
constexpr UInt16 operator- (UInt16 lhs, UInt8 rhs) noexcept
 
constexpr UInt16 operator- (UInt16 value)
 
constexpr UInt32 operator- (UInt32 lhs, std::uint32_t rhs) noexcept
 
constexpr UInt32 operator- (UInt32 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator- (UInt32 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator- (UInt32 lhs, UInt64 rhs) noexcept
 
constexpr UInt32 operator- (UInt32 lhs, UInt8 rhs) noexcept
 
constexpr UInt32 operator- (UInt32 value)
 
constexpr UInt64 operator- (UInt64 lhs, std::uint64_t rhs) noexcept
 
constexpr UInt64 operator- (UInt64 lhs, UInt16 rhs) noexcept
 
constexpr UInt64 operator- (UInt64 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator- (UInt64 lhs, UInt64 rhs) noexcept
 
constexpr UInt64 operator- (UInt64 lhs, UInt8 rhs) noexcept
 
constexpr UInt64 operator- (UInt64 value)
 
constexpr UInt8 operator- (UInt8 lhs, std::uint8_t rhs) noexcept
 
constexpr UInt16 operator- (UInt8 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator- (UInt8 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator- (UInt8 lhs, UInt64 rhs) noexcept
 
constexpr UInt8 operator- (UInt8 lhs, UInt8 rhs) noexcept
 
constexpr UInt8 operator- (UInt8 value)
 
template<typename Iterator1 , class Iterator2 , typename Tag >
constexpr auto operator- (wrap_iter< Iterator1, Tag > const &x, wrap_iter< Iterator2, Tag > const &y) noexcept
 
constexpr UInt16operator-- (UInt16 &value)
 
constexpr UInt16 operator-- (UInt16 &value, int)
 
constexpr UInt32operator-- (UInt32 &value)
 
constexpr UInt32 operator-- (UInt32 &value, int)
 
constexpr UInt64operator-- (UInt64 &value)
 
constexpr UInt64 operator-- (UInt64 &value, int)
 
constexpr UInt8operator-- (UInt8 &value)
 
constexpr UInt8 operator-- (UInt8 &value, int)
 
constexpr std::uint16_t & operator-= (std::uint16_t &lhs, UInt16 rhs) noexcept
 
constexpr std::uint16_t & operator-= (std::uint16_t &lhs, UInt8 rhs) noexcept
 
constexpr std::uint32_t & operator-= (std::uint32_t &lhs, UInt16 rhs) noexcept
 
constexpr std::uint32_t & operator-= (std::uint32_t &lhs, UInt32 rhs) noexcept
 
constexpr std::uint32_t & operator-= (std::uint32_t &lhs, UInt8 rhs) noexcept
 
constexpr std::uint64_t & operator-= (std::uint64_t &lhs, UInt64 rhs) noexcept
 
constexpr std::uint8_t & operator-= (std::uint8_t &lhs, UInt8 rhs) noexcept
 
constexpr UInt16operator-= (UInt16 &lhs, std::uint16_t rhs) noexcept
 
constexpr UInt16operator-= (UInt16 &lhs, UInt16 rhs) noexcept
 
constexpr UInt16operator-= (UInt16 &lhs, UInt8 rhs) noexcept
 
constexpr UInt32operator-= (UInt32 &lhs, std::uint32_t rhs) noexcept
 
constexpr UInt32operator-= (UInt32 &lhs, UInt16 rhs) noexcept
 
constexpr UInt32operator-= (UInt32 &lhs, UInt32 rhs) noexcept
 
constexpr UInt32operator-= (UInt32 &lhs, UInt8 rhs) noexcept
 
constexpr UInt64operator-= (UInt64 &lhs, std::uint64_t rhs) noexcept
 
constexpr UInt64operator-= (UInt64 &lhs, UInt16 rhs) noexcept
 
constexpr UInt64operator-= (UInt64 &lhs, UInt32 rhs) noexcept
 
constexpr UInt64operator-= (UInt64 &lhs, UInt64 rhs) noexcept
 
constexpr UInt64operator-= (UInt64 &lhs, UInt8 rhs) noexcept
 
constexpr UInt8operator-= (UInt8 &lhs, std::uint8_t rhs) noexcept
 
constexpr UInt8operator-= (UInt8 &lhs, UInt8 rhs) noexcept
 
constexpr UInt16 operator/ (std::uint16_t lhs, UInt16 rhs) noexcept
 
constexpr UInt16 operator/ (std::uint16_t lhs, UInt8 rhs) noexcept
 
constexpr UInt32 operator/ (std::uint32_t lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator/ (std::uint32_t lhs, UInt32 rhs) noexcept
 
constexpr UInt32 operator/ (std::uint32_t lhs, UInt8 rhs) noexcept
 
constexpr UInt64 operator/ (std::uint64_t lhs, UInt16 rhs) noexcept
 
constexpr UInt64 operator/ (std::uint64_t lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator/ (std::uint64_t lhs, UInt64 rhs) noexcept
 
constexpr UInt64 operator/ (std::uint64_t lhs, UInt8 rhs) noexcept
 
constexpr UInt8 operator/ (std::uint8_t lhs, UInt64 rhs) noexcept
 
constexpr UInt16 operator/ (UInt16 lhs, std::uint16_t rhs) noexcept
 
constexpr UInt16 operator/ (UInt16 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator/ (UInt16 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator/ (UInt16 lhs, UInt64 rhs) noexcept
 
constexpr UInt16 operator/ (UInt16 lhs, UInt8 rhs) noexcept
 
constexpr UInt32 operator/ (UInt32 lhs, std::uint32_t rhs) noexcept
 
constexpr UInt32 operator/ (UInt32 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator/ (UInt32 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator/ (UInt32 lhs, UInt64 rhs) noexcept
 
constexpr UInt32 operator/ (UInt32 lhs, UInt8 rhs) noexcept
 
constexpr UInt64 operator/ (UInt64 lhs, std::uint64_t rhs) noexcept
 
constexpr UInt64 operator/ (UInt64 lhs, UInt16 rhs) noexcept
 
constexpr UInt64 operator/ (UInt64 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator/ (UInt64 lhs, UInt64 rhs) noexcept
 
constexpr UInt64 operator/ (UInt64 lhs, UInt8 rhs) noexcept
 
constexpr UInt8 operator/ (UInt8 lhs, std::uint64_t rhs) noexcept
 
constexpr UInt16 operator/ (UInt8 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator/ (UInt8 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator/ (UInt8 lhs, UInt64 rhs) noexcept
 
constexpr UInt8 operator/ (UInt8 lhs, UInt8 rhs) noexcept
 
constexpr std::uint16_t & operator/= (std::uint16_t &lhs, UInt16 rhs) noexcept
 
constexpr std::uint16_t & operator/= (std::uint16_t &lhs, UInt8 rhs) noexcept
 
constexpr std::uint32_t & operator/= (std::uint32_t &lhs, UInt32 rhs) noexcept
 
constexpr std::uint64_t & operator/= (std::uint64_t &lhs, UInt16 rhs) noexcept
 
constexpr std::uint64_t & operator/= (std::uint64_t &lhs, UInt32 rhs) noexcept
 
constexpr std::uint64_t & operator/= (std::uint64_t &lhs, UInt64 rhs) noexcept
 
constexpr std::uint64_t & operator/= (std::uint64_t &lhs, UInt8 rhs) noexcept
 
constexpr std::uint8_t & operator/= (std::uint8_t &lhs, UInt64 rhs) noexcept
 
constexpr UInt16operator/= (UInt16 &lhs, std::uint16_t rhs) noexcept
 
constexpr UInt16operator/= (UInt16 &lhs, UInt16 rhs) noexcept
 
constexpr UInt16operator/= (UInt16 &lhs, UInt8 rhs) noexcept
 
constexpr UInt32operator/= (UInt32 &lhs, std::uint32_t rhs) noexcept
 
constexpr UInt32operator/= (UInt32 &lhs, UInt16 rhs) noexcept
 
constexpr UInt32operator/= (UInt32 &lhs, UInt32 rhs) noexcept
 
constexpr UInt32operator/= (UInt32 &lhs, UInt8 rhs) noexcept
 
constexpr UInt64operator/= (UInt64 &lhs, std::uint64_t rhs) noexcept
 
constexpr UInt64operator/= (UInt64 &lhs, UInt16 rhs) noexcept
 
constexpr UInt64operator/= (UInt64 &lhs, UInt32 rhs) noexcept
 
constexpr UInt64operator/= (UInt64 &lhs, UInt64 rhs) noexcept
 
constexpr UInt64operator/= (UInt64 &lhs, UInt8 rhs) noexcept
 
constexpr UInt8operator/= (UInt8 &lhs, std::uint64_t rhs) noexcept
 
constexpr UInt8operator/= (UInt8 &lhs, UInt8 rhs) noexcept
 
template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool operator< (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept
 
template<typename CharT , size_t Capacity, size_t N>
constexpr bool operator< (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator< (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator< (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept
 
template<typename CharT , size_t Capacity, size_t N>
constexpr bool operator< (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept
 
template<typename CharT , size_t Capacity>
constexpr bool operator< (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept
 
template<typename CharT , size_t Capacity>
bool operator< (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept
 
template<typename CharT , size_t Capacity>
constexpr bool operator< (daw::basic_bounded_string< CharT, Capacity > const &lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept
 
template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool operator< (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept
 
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool operator< (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept
 
template<typename T >
bool operator< (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs)
 
template<typename CharT , size_t Capacity>
constexpr bool operator< (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T , typename U >
bool operator< (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs)
 
template<typename T , typename U >
bool operator< (heap_value< T > const &lhs, heap_value< U > const &rhs)
 
template<typename T >
constexpr bool operator< (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator< (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept
 
constexpr bool operator< (node_id_t const &lhs, node_id_t const &rhs) noexcept
 
template<typename T >
constexpr bool operator< (optional< T > const &, std::nullopt_t) noexcept
 
template<typename T , typename U >
constexpr bool operator< (optional< T > const &lhs, optional< U > const &rhs)
 
template<typename T , typename U >
constexpr bool operator< (optional< T > const &opt, U const &value)
 
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool operator< (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept
 
template<typename T >
bool operator< (Reference< T > const &lhs, Reference< T > const &rhs)
 
template<typename Iterator1 , typename Iterator2 >
constexpr bool operator< (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs)
 
template<typename CharT , size_t Capacity>
constexpr bool operator< (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T >
constexpr bool operator< (std::nullopt_t, optional< T > const &opt) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator< (std::nullptr_t, copiable_unique_ptr< T1, D1 > const &rhs) noexcept
 
constexpr bool operator< (std::uint16_t lhs, UInt16 rhs) noexcept
 
constexpr bool operator< (std::uint32_t lhs, UInt32 rhs) noexcept
 
constexpr bool operator< (std::uint64_t lhs, UInt16 rhs) noexcept
 
constexpr bool operator< (std::uint64_t lhs, UInt32 rhs) noexcept
 
constexpr bool operator< (std::uint64_t lhs, UInt64 rhs) noexcept
 
constexpr bool operator< (std::uint64_t lhs, UInt8 rhs) noexcept
 
constexpr bool operator< (std::uint8_t lhs, UInt8 rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator< (T const &value, optional< U > const &opt)
 
template<typename CharT , size_t Capacity>
constexpr bool operator< (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
constexpr bool operator< (UInt16 lhs, std::uint16_t rhs) noexcept
 
constexpr bool operator< (UInt32 lhs, std::uint32_t rhs) noexcept
 
constexpr bool operator< (UInt64 lhs, std::uint64_t rhs) noexcept
 
constexpr bool operator< (UInt8 lhs, std::uint8_t rhs) noexcept
 
template<typename T , typename D0 , typename D1 = D0>
constexpr bool operator< (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept
 
template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_less< T, U >, std::nullptr_t > = nullptr>
constexpr bool operator< (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs< *rhs))
 
template<typename OStream , typename CharT , size_t Capacity, std::enable_if_t< daw::traits::is_ostream_like_v< OStream, CharT >, std::nullptr_t > = nullptr>
OStreamoperator<< (OStream &os, daw::basic_bounded_string< CharT, Capacity > const &str)
 
template<typename OStream , typename T , std::enable_if_t< daw::traits::is_ostream_like_lite_v< OStream >, std::nullptr_t > = nullptr>
OStreamoperator<< (OStream &os, Reference< T > const &ref)
 
template<size_t BitWidth>
std::ostream & operator<< (std::ostream &os, static_bitset< BitWidth > const &bs)
 
std::ostream & operator<< (std::ostream &os, UInt16 rhs)
 
std::ostream & operator<< (std::ostream &os, UInt32 rhs)
 
std::ostream & operator<< (std::ostream &os, UInt64 rhs)
 
std::ostream & operator<< (std::ostream &os, UInt8 rhs)
 
constexpr std::uint16_t operator<< (std::uint16_t b, UInt16 shift) noexcept
 
constexpr std::uint32_t operator<< (std::uint32_t b, UInt32 shift) noexcept
 
constexpr std::uint64_t operator<< (std::uint64_t b, UInt16 shift) noexcept
 
constexpr std::uint64_t operator<< (std::uint64_t b, UInt32 shift) noexcept
 
constexpr std::uint64_t operator<< (std::uint64_t b, UInt64 shift) noexcept
 
constexpr std::uint64_t operator<< (std::uint64_t b, UInt8 shift) noexcept
 
constexpr std::uint8_t operator<< (std::uint8_t b, UInt8 shift) noexcept
 
constexpr UInt16 operator<< (UInt16 b, std::uint16_t shift) noexcept
 
constexpr UInt16 operator<< (UInt16 b, UInt16 shift) noexcept
 
constexpr UInt16 operator<< (UInt16 b, UInt8 shift) noexcept
 
constexpr UInt32 operator<< (UInt32 b, std::uint32_t shift) noexcept
 
constexpr UInt32 operator<< (UInt32 b, UInt16 shift) noexcept
 
constexpr UInt32 operator<< (UInt32 b, UInt32 shift) noexcept
 
constexpr UInt32 operator<< (UInt32 b, UInt8 shift) noexcept
 
constexpr UInt64 operator<< (UInt64 b, std::uint64_t shift) noexcept
 
constexpr UInt64 operator<< (UInt64 b, UInt16 shift) noexcept
 
constexpr UInt64 operator<< (UInt64 b, UInt32 shift) noexcept
 
constexpr UInt64 operator<< (UInt64 b, UInt64 shift) noexcept
 
constexpr UInt64 operator<< (UInt64 b, UInt8 shift) noexcept
 
constexpr UInt8 operator<< (UInt8 b, std::uint8_t shift) noexcept
 
constexpr UInt8 operator<< (UInt8 b, UInt8 shift) noexcept
 
constexpr UInt16operator<<= (UInt16 &b, std::uint16_t shift) noexcept
 
constexpr UInt16operator<<= (UInt16 &b, UInt16 shift) noexcept
 
constexpr UInt16operator<<= (UInt16 &b, UInt8 shift) noexcept
 
constexpr UInt32operator<<= (UInt32 &b, std::uint32_t shift) noexcept
 
constexpr UInt32operator<<= (UInt32 &b, UInt16 shift) noexcept
 
constexpr UInt32operator<<= (UInt32 &b, UInt32 shift) noexcept
 
constexpr UInt32operator<<= (UInt32 &b, UInt8 shift) noexcept
 
constexpr UInt64operator<<= (UInt64 &b, std::uint64_t shift) noexcept
 
constexpr UInt64operator<<= (UInt64 &b, UInt16 shift) noexcept
 
constexpr UInt64operator<<= (UInt64 &b, UInt32 shift) noexcept
 
constexpr UInt64operator<<= (UInt64 &b, UInt64 shift) noexcept
 
constexpr UInt64operator<<= (UInt64 &b, UInt8 shift) noexcept
 
constexpr UInt8operator<<= (UInt8 &b, std::uint8_t shift) noexcept
 
constexpr UInt8operator<<= (UInt8 &b, UInt8 shift) noexcept
 
template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool operator<= (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept
 
template<typename CharT , size_t Capacity, size_t N>
constexpr bool operator<= (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator<= (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator<= (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept
 
template<typename CharT , size_t Capacity, size_t N>
constexpr bool operator<= (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept
 
template<typename CharT , size_t Capacity>
constexpr bool operator<= (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept
 
template<typename CharT , size_t Capacity>
bool operator<= (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept
 
template<typename CharT , size_t Capacity>
constexpr bool operator<= (daw::basic_bounded_string< CharT, Capacity > const &lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept
 
template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool operator<= (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept
 
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool operator<= (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept
 
template<typename T >
bool operator<= (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs)
 
template<typename CharT , size_t Capacity>
constexpr bool operator<= (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T , typename U >
bool operator<= (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs)
 
template<typename T , typename U >
bool operator<= (heap_value< T > const &lhs, heap_value< U > const &rhs)
 
template<typename T >
constexpr bool operator<= (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator<= (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator<= (optional< T > const &lhs, optional< U > const &rhs)
 
template<typename T >
constexpr bool operator<= (optional< T > const &opt, std::nullopt_t) noexcept
 
template<typename T , typename U >
constexpr bool operator<= (optional< T > const &opt, U const &value)
 
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool operator<= (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept
 
template<typename T >
bool operator<= (Reference< T > const &lhs, Reference< T > const &rhs)
 
template<typename Iterator1 , typename Iterator2 >
constexpr bool operator<= (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs)
 
template<typename CharT , size_t Capacity>
constexpr bool operator<= (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T >
constexpr bool operator<= (std::nullopt_t, optional< T > const &) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator<= (std::nullptr_t, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
 
constexpr bool operator<= (std::uint16_t lhs, UInt16 rhs) noexcept
 
constexpr bool operator<= (std::uint32_t lhs, UInt32 rhs) noexcept
 
constexpr bool operator<= (std::uint64_t lhs, UInt16 rhs) noexcept
 
constexpr bool operator<= (std::uint64_t lhs, UInt32 rhs) noexcept
 
constexpr bool operator<= (std::uint64_t lhs, UInt64 rhs) noexcept
 
constexpr bool operator<= (std::uint64_t lhs, UInt8 rhs) noexcept
 
constexpr bool operator<= (std::uint8_t lhs, UInt8 rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator<= (T const &value, optional< U > const &opt)
 
template<typename CharT , size_t Capacity>
constexpr bool operator<= (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
constexpr bool operator<= (UInt16 lhs, std::uint16_t rhs) noexcept
 
constexpr bool operator<= (UInt16 lhs, std::uint64_t rhs) noexcept
 
constexpr bool operator<= (UInt32 lhs, std::uint32_t rhs) noexcept
 
constexpr bool operator<= (UInt32 lhs, std::uint64_t rhs) noexcept
 
constexpr bool operator<= (UInt64 lhs, std::uint64_t rhs) noexcept
 
constexpr bool operator<= (UInt8 lhs, std::uint64_t rhs) noexcept
 
constexpr bool operator<= (UInt8 lhs, std::uint8_t rhs) noexcept
 
template<typename T , typename D0 , typename D1 = D0>
constexpr bool operator<= (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept
 
template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_less_equal< T, U >, std::nullptr_t > = nullptr>
constexpr bool operator<= (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs<= *rhs))
 
template<typename T , typename U , size_t N>
constexpr bool operator== (array< T, N > const &lhs, array< U, N > const &rhs)
 
template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool operator== (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept
 
template<typename Key , typename Value >
constexpr bool operator== (bounded_hash_map_iterator< Key, Value > const &lhs, bounded_hash_map_iterator< Key, Value > const &rhs)
 
template<typename Key , typename Value >
constexpr bool operator== (bounded_hash_map_iterator< Key, Value > const &lhs, const_bounded_hash_map_iterator< Key, Value > const &rhs)
 
template<typename Key >
constexpr bool operator== (bounded_hash_set_iterator< Key > const &lhs, bounded_hash_set_iterator< Key > const &rhs) noexcept
 
template<typename Key >
constexpr bool operator== (bounded_hash_set_iterator< Key > const &lhs, const_bounded_hash_set_iterator< Key > const &rhs) noexcept
 
template<typename CharT , size_t Capacity, size_t N>
constexpr bool operator== (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename Key , typename Value >
constexpr bool operator== (const_bounded_hash_map_iterator< Key, Value > const &lhs, bounded_hash_map_iterator< Key, Value > const &rhs)
 
template<typename Key , typename Value >
constexpr bool operator== (const_bounded_hash_map_iterator< Key, Value > const &lhs, const_bounded_hash_map_iterator< Key, Value > const &rhs)
 
template<typename Key >
constexpr bool operator== (const_bounded_hash_set_iterator< Key > const &lhs, bounded_hash_set_iterator< Key > const &rhs) noexcept
 
template<typename Key >
constexpr bool operator== (const_bounded_hash_set_iterator< Key > const &lhs, const_bounded_hash_set_iterator< Key > const &rhs) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator== (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator== (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept
 
template<typename CharT , size_t Capacity, size_t N>
constexpr bool operator== (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept
 
template<typename CharT , size_t Capacity>
constexpr bool operator== (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept
 
template<typename CharT , size_t Capacity>
bool operator== (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept
 
template<typename CharT , size_t Capacity>
constexpr bool operator== (daw::basic_bounded_string< CharT, Capacity > const &lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept
 
template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool operator== (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept
 
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool operator== (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept
 
template<typename T >
bool operator== (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs)
 
template<typename CharT , size_t Capacity>
constexpr bool operator== (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T , typename U >
bool operator== (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs)
 
template<typename T , typename U >
bool operator== (heap_value< T > const &lhs, heap_value< U > const &rhs)
 
template<typename T , typename U , std::enable_if_t< not std::is_convertible_v< T, U >, std::nullptr_t > = nullptr>
constexpr bool operator== (indexed_iterator< T > const &, indexed_iterator< U > const &) noexcept
 
template<typename T >
constexpr bool operator== (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator== (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept
 
constexpr bool operator== (node_id_t const &lhs, node_id_t const &rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator== (optional< T > const &lhs, optional< U > const &rhs)
 
template<typename T >
constexpr bool operator== (optional< T > const &opt, std::nullopt_t) noexcept
 
template<typename T , typename U >
constexpr bool operator== (optional< T > const &opt, U const &value)
 
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool operator== (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept
 
template<typename T >
bool operator== (Reference< T > const &lhs, Reference< T > const &rhs)
 
template<typename CharT >
constexpr bool operator== (repeat_n_char_iterator< CharT > const &lhs, repeat_n_char_iterator< CharT > const &rhs) noexcept
 
template<typename Iterator1 , typename Iterator2 >
constexpr bool operator== (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs)
 
template<typename Iterator >
constexpr bool operator== (splitter_range_t< Iterator > const &lhs, splitter_range_t< Iterator > const &rhs) noexcept
 
template<typename CharT , size_t Capacity>
constexpr bool operator== (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T >
constexpr bool operator== (std::nullopt_t, optional< T > const &opt) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator== (std::nullptr_t, copiable_unique_ptr< T1, D1 > const &rhs) noexcept
 
constexpr bool operator== (std::uint16_t lhs, UInt16 rhs) noexcept
 
constexpr bool operator== (std::uint32_t lhs, UInt32 rhs) noexcept
 
constexpr bool operator== (std::uint64_t lhs, UInt16 rhs) noexcept
 
constexpr bool operator== (std::uint64_t lhs, UInt32 rhs) noexcept
 
constexpr bool operator== (std::uint64_t lhs, UInt64 rhs) noexcept
 
constexpr bool operator== (std::uint64_t lhs, UInt8 rhs) noexcept
 
constexpr bool operator== (std::uint8_t lhs, UInt8 rhs) noexcept
 
template<typename CharT >
constexpr bool operator== (string_split_iterator< CharT > const &lhs, string_split_iterator< CharT > const &rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator== (T const &value, optional< U > const &opt)
 
template<typename CharT , size_t Capacity>
constexpr bool operator== (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
constexpr bool operator== (UInt16 lhs, std::uint16_t rhs) noexcept
 
constexpr bool operator== (UInt32 lhs, std::uint32_t rhs) noexcept
 
constexpr bool operator== (UInt64 lhs, std::uint64_t rhs) noexcept
 
constexpr bool operator== (UInt64 lhs, UInt16 rhs) noexcept
 
constexpr bool operator== (UInt64 lhs, UInt32 rhs) noexcept
 
constexpr bool operator== (UInt64 lhs, UInt8 rhs) noexcept
 
constexpr bool operator== (UInt8 lhs, std::uint8_t rhs) noexcept
 
template<typename T , typename D0 , typename D1 = D0>
constexpr bool operator== (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept
 
template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_equality< T, U >, std::nullptr_t > = nullptr>
constexpr bool operator== (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs== *rhs))
 
template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool operator> (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept
 
template<typename CharT , size_t Capacity, size_t N>
constexpr bool operator> (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator> (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator> (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept
 
template<typename CharT , size_t Capacity, size_t N>
constexpr bool operator> (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept
 
template<typename CharT , size_t Capacity>
constexpr bool operator> (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept
 
template<typename CharT , size_t Capacity>
bool operator> (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept
 
template<typename CharT , size_t Capacity>
constexpr bool operator> (daw::basic_bounded_string< CharT, Capacity > const &lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept
 
template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool operator> (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept
 
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool operator> (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept
 
template<typename T >
bool operator> (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs)
 
template<typename CharT , size_t Capacity>
constexpr bool operator> (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T , typename U >
bool operator> (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs)
 
template<typename T , typename U >
bool operator> (heap_value< T > const &lhs, heap_value< U > const &rhs)
 
template<typename T >
constexpr bool operator> (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator> (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator> (optional< T > const &lhs, optional< U > const &rhs)
 
template<typename T >
constexpr bool operator> (optional< T > const &opt, std::nullopt_t) noexcept
 
template<typename T , typename U >
constexpr bool operator> (optional< T > const &opt, U const &value)
 
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool operator> (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept
 
template<typename T >
bool operator> (Reference< T > const &lhs, Reference< T > const &rhs)
 
template<typename Iterator1 , typename Iterator2 >
constexpr bool operator> (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs)
 
template<typename CharT , size_t Capacity>
constexpr bool operator> (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T >
constexpr bool operator> (std::nullopt_t, optional< T > const &) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator> (std::nullptr_t, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
 
constexpr bool operator> (std::uint16_t lhs, UInt16 rhs) noexcept
 
constexpr bool operator> (std::uint64_t lhs, UInt16 rhs) noexcept
 
constexpr bool operator> (std::uint64_t lhs, UInt32 rhs) noexcept
 
constexpr bool operator> (std::uint64_t lhs, UInt64 rhs) noexcept
 
constexpr bool operator> (std::uint64_t lhs, UInt8 rhs) noexcept
 
constexpr bool operator> (std::uint8_t lhs, UInt8 rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator> (T const &value, optional< U > const &opt)
 
template<typename CharT , size_t Capacity>
constexpr bool operator> (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
constexpr bool operator> (UInt16 lhs, std::uint16_t rhs) noexcept
 
constexpr bool operator> (UInt16 lhs, std::uint64_t rhs) noexcept
 
constexpr bool operator> (UInt32 lhs, std::uint64_t rhs) noexcept
 
constexpr bool operator> (UInt64 lhs, std::uint64_t rhs) noexcept
 
constexpr bool operator> (UInt8 lhs, std::uint64_t rhs) noexcept
 
constexpr bool operator> (UInt8 lhs, std::uint8_t rhs) noexcept
 
template<typename T , typename D0 , typename D1 = D0>
constexpr bool operator> (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept
 
template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_greater< T, U >, std::nullptr_t > = nullptr>
constexpr bool operator> (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs > *rhs))
 
template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool operator>= (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept
 
template<typename CharT , size_t Capacity, size_t N>
constexpr bool operator>= (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator>= (const T &value, const optional< U > &opt)
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator>= (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator>= (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept
 
template<typename CharT , size_t Capacity, size_t N>
constexpr bool operator>= (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept
 
template<typename CharT , size_t Capacity>
constexpr bool operator>= (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept
 
template<typename CharT , size_t Capacity>
bool operator>= (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept
 
template<typename CharT , size_t Capacity>
constexpr bool operator>= (daw::basic_bounded_string< CharT, Capacity > lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept
 
template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool operator>= (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept
 
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool operator>= (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept
 
template<typename T >
bool operator>= (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs)
 
template<typename CharT , size_t Capacity>
constexpr bool operator>= (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T , typename U >
bool operator>= (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs)
 
template<typename T , typename U >
bool operator>= (heap_value< T > const &lhs, heap_value< U > const &rhs)
 
template<typename T >
constexpr bool operator>= (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept
 
template<typename T , typename U >
constexpr bool operator>= (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept
 
template<typename T >
constexpr bool operator>= (optional< T > const &, std::nullopt_t) noexcept
 
template<typename T , typename U >
constexpr bool operator>= (optional< T > const &lhs, optional< U > const &rhs)
 
template<typename T , typename U >
constexpr bool operator>= (optional< T > const &opt, U const &value)
 
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool operator>= (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept
 
template<typename T >
bool operator>= (Reference< T > const &lhs, Reference< T > const &rhs)
 
template<typename Iterator1 , typename Iterator2 >
constexpr bool operator>= (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs)
 
template<typename CharT , size_t Capacity>
constexpr bool operator>= (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
template<typename T >
constexpr bool operator>= (std::nullopt_t, optional< T > const &opt) noexcept
 
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool operator>= (std::nullptr_t, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
 
constexpr bool operator>= (std::uint16_t lhs, UInt16 rhs) noexcept
 
constexpr bool operator>= (std::uint32_t lhs, UInt32 rhs) noexcept
 
constexpr bool operator>= (std::uint64_t lhs, UInt16 rhs) noexcept
 
constexpr bool operator>= (std::uint64_t lhs, UInt32 rhs) noexcept
 
constexpr bool operator>= (std::uint64_t lhs, UInt64 rhs) noexcept
 
constexpr bool operator>= (std::uint64_t lhs, UInt8 rhs) noexcept
 
constexpr bool operator>= (std::uint8_t lhs, UInt8 rhs) noexcept
 
template<typename CharT , size_t Capacity>
constexpr bool operator>= (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
 
constexpr bool operator>= (UInt16 lhs, std::uint16_t rhs) noexcept
 
constexpr bool operator>= (UInt16 lhs, std::uint64_t rhs) noexcept
 
constexpr bool operator>= (UInt32 lhs, std::uint32_t rhs) noexcept
 
constexpr bool operator>= (UInt32 lhs, std::uint64_t rhs) noexcept
 
constexpr bool operator>= (UInt64 lhs, std::uint64_t rhs) noexcept
 
constexpr bool operator>= (UInt8 lhs, std::uint64_t rhs) noexcept
 
constexpr bool operator>= (UInt8 lhs, std::uint8_t rhs) noexcept
 
template<typename T , typename D0 , typename D1 = D0>
constexpr bool operator>= (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept
 
template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_greater_equal< T, U >, std::nullptr_t > = nullptr>
constexpr bool operator>= (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs >= *rhs))
 
constexpr std::uint16_t operator>> (std::uint16_t b, UInt16 shift) noexcept
 
constexpr std::uint32_t operator>> (std::uint32_t b, UInt16 shift) noexcept
 
constexpr std::uint32_t operator>> (std::uint32_t b, UInt32 shift) noexcept
 
constexpr std::uint32_t operator>> (std::uint32_t b, UInt8 shift) noexcept
 
constexpr std::uint64_t operator>> (std::uint64_t b, UInt16 shift) noexcept
 
constexpr std::uint64_t operator>> (std::uint64_t b, UInt32 shift) noexcept
 
constexpr std::uint64_t operator>> (std::uint64_t b, UInt64 shift) noexcept
 
constexpr std::uint64_t operator>> (std::uint64_t b, UInt8 shift) noexcept
 
constexpr std::uint8_t operator>> (std::uint8_t b, UInt8 shift) noexcept
 
constexpr UInt16 operator>> (UInt16 b, std::uint16_t shift) noexcept
 
constexpr UInt16 operator>> (UInt16 b, UInt16 shift) noexcept
 
constexpr UInt32 operator>> (UInt32 b, std::uint32_t shift) noexcept
 
constexpr UInt32 operator>> (UInt32 b, UInt16 shift) noexcept
 
constexpr UInt32 operator>> (UInt32 b, UInt32 shift) noexcept
 
constexpr UInt32 operator>> (UInt32 b, UInt8 shift) noexcept
 
constexpr UInt64 operator>> (UInt64 b, std::uint64_t shift) noexcept
 
constexpr UInt64 operator>> (UInt64 b, UInt16 shift) noexcept
 
constexpr UInt64 operator>> (UInt64 b, UInt32 shift) noexcept
 
constexpr UInt64 operator>> (UInt64 b, UInt64 shift) noexcept
 
constexpr UInt64 operator>> (UInt64 b, UInt8 shift) noexcept
 
constexpr UInt8 operator>> (UInt8 b, std::uint8_t shift) noexcept
 
constexpr UInt8 operator>> (UInt8 b, UInt8 shift) noexcept
 
constexpr UInt16operator>>= (UInt16 &b, std::uint16_t shift) noexcept
 
constexpr UInt16operator>>= (UInt16 &b, UInt16 shift) noexcept
 
constexpr UInt16operator>>= (UInt16 &b, UInt8 shift) noexcept
 
constexpr UInt32operator>>= (UInt32 &b, std::uint32_t shift) noexcept
 
constexpr UInt32operator>>= (UInt32 &b, UInt16 shift) noexcept
 
constexpr UInt32operator>>= (UInt32 &b, UInt32 shift) noexcept
 
constexpr UInt32operator>>= (UInt32 &b, UInt8 shift) noexcept
 
constexpr UInt64operator>>= (UInt64 &b, std::uint64_t shift) noexcept
 
constexpr UInt64operator>>= (UInt64 &b, UInt16 shift) noexcept
 
constexpr UInt64operator>>= (UInt64 &b, UInt32 shift) noexcept
 
constexpr UInt64operator>>= (UInt64 &b, UInt64 shift) noexcept
 
constexpr UInt64operator>>= (UInt64 &b, UInt8 shift) noexcept
 
constexpr UInt8operator>>= (UInt8 &b, std::uint8_t shift) noexcept
 
constexpr UInt8operator>>= (UInt8 &b, UInt8 shift) noexcept
 
constexpr UInt16 operator^ (std::uint16_t lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator^ (std::uint32_t lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator^ (std::uint64_t lhs, UInt64 rhs) noexcept
 
constexpr UInt8 operator^ (std::uint8_t lhs, UInt8 rhs) noexcept
 
constexpr UInt16 operator^ (UInt16 lhs, std::uint16_t rhs) noexcept
 
constexpr UInt16 operator^ (UInt16 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator^ (UInt16 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator^ (UInt16 lhs, UInt64 rhs) noexcept
 
constexpr UInt16 operator^ (UInt16 lhs, UInt8 rhs) noexcept
 
constexpr UInt32 operator^ (UInt32 lhs, std::uint32_t rhs) noexcept
 
constexpr UInt32 operator^ (UInt32 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator^ (UInt32 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator^ (UInt32 lhs, UInt64 rhs) noexcept
 
constexpr UInt32 operator^ (UInt32 lhs, UInt8 rhs) noexcept
 
constexpr UInt64 operator^ (UInt64 lhs, std::uint64_t rhs) noexcept
 
constexpr UInt64 operator^ (UInt64 lhs, UInt16 rhs) noexcept
 
constexpr UInt64 operator^ (UInt64 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator^ (UInt64 lhs, UInt64 rhs) noexcept
 
constexpr UInt64 operator^ (UInt64 lhs, UInt8 rhs) noexcept
 
constexpr UInt8 operator^ (UInt8 lhs, std::uint8_t rhs) noexcept
 
constexpr UInt32 operator^ (UInt8 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator^ (UInt8 lhs, UInt64 rhs) noexcept
 
constexpr UInt8 operator^ (UInt8 lhs, UInt8 rhs) noexcept
 
constexpr UInt16operator^= (UInt16 &lhs, std::uint16_t rhs) noexcept
 
constexpr UInt16operator^= (UInt16 &lhs, UInt16 rhs) noexcept
 
constexpr UInt16operator^= (UInt16 &lhs, UInt8 rhs) noexcept
 
constexpr UInt32operator^= (UInt32 &lhs, std::uint32_t rhs) noexcept
 
constexpr UInt32operator^= (UInt32 &lhs, UInt16 rhs) noexcept
 
constexpr UInt32operator^= (UInt32 &lhs, UInt32 rhs) noexcept
 
constexpr UInt32operator^= (UInt32 &lhs, UInt8 rhs) noexcept
 
constexpr UInt64operator^= (UInt64 &lhs, std::uint64_t rhs) noexcept
 
constexpr UInt64operator^= (UInt64 &lhs, UInt16 rhs) noexcept
 
constexpr UInt64operator^= (UInt64 &lhs, UInt32 rhs) noexcept
 
constexpr UInt64operator^= (UInt64 &lhs, UInt64 rhs) noexcept
 
constexpr UInt64operator^= (UInt64 &lhs, UInt8 rhs) noexcept
 
constexpr UInt8operator^= (UInt8 &lhs, std::uint8_t rhs) noexcept
 
constexpr UInt8operator^= (UInt8 &lhs, UInt8 rhs) noexcept
 
constexpr UInt16 operator| (std::uint16_t lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator| (std::uint32_t lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator| (std::uint64_t lhs, UInt64 rhs) noexcept
 
constexpr UInt8 operator| (std::uint8_t lhs, UInt8 rhs) noexcept
 
constexpr UInt16 operator| (UInt16 lhs, std::uint16_t rhs) noexcept
 
constexpr UInt16 operator| (UInt16 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator| (UInt16 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator| (UInt16 lhs, UInt64 rhs) noexcept
 
constexpr UInt16 operator| (UInt16 lhs, UInt8 rhs) noexcept
 
constexpr UInt32 operator| (UInt32 lhs, std::uint32_t rhs) noexcept
 
constexpr UInt32 operator| (UInt32 lhs, UInt16 rhs) noexcept
 
constexpr UInt32 operator| (UInt32 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator| (UInt32 lhs, UInt64 rhs) noexcept
 
constexpr UInt32 operator| (UInt32 lhs, UInt8 rhs) noexcept
 
constexpr UInt64 operator| (UInt64 lhs, std::uint64_t rhs) noexcept
 
constexpr UInt64 operator| (UInt64 lhs, UInt16 rhs) noexcept
 
constexpr UInt64 operator| (UInt64 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator| (UInt64 lhs, UInt64 rhs) noexcept
 
constexpr UInt64 operator| (UInt64 lhs, UInt8 rhs) noexcept
 
constexpr UInt8 operator| (UInt8 lhs, std::uint8_t rhs) noexcept
 
constexpr UInt32 operator| (UInt8 lhs, UInt32 rhs) noexcept
 
constexpr UInt64 operator| (UInt8 lhs, UInt64 rhs) noexcept
 
constexpr UInt8 operator| (UInt8 lhs, UInt8 rhs) noexcept
 
constexpr UInt16operator|= (UInt16 &lhs, std::uint16_t rhs) noexcept
 
constexpr UInt16operator|= (UInt16 &lhs, UInt16 rhs) noexcept
 
constexpr UInt16operator|= (UInt16 &lhs, UInt8 rhs) noexcept
 
constexpr UInt32operator|= (UInt32 &lhs, std::uint32_t rhs) noexcept
 
constexpr UInt32operator|= (UInt32 &lhs, UInt16 rhs) noexcept
 
constexpr UInt32operator|= (UInt32 &lhs, UInt32 rhs) noexcept
 
constexpr UInt32operator|= (UInt32 &lhs, UInt8 rhs) noexcept
 
constexpr UInt64operator|= (UInt64 &lhs, std::uint64_t rhs) noexcept
 
constexpr UInt64operator|= (UInt64 &lhs, UInt16 rhs) noexcept
 
constexpr UInt64operator|= (UInt64 &lhs, UInt32 rhs) noexcept
 
constexpr UInt64operator|= (UInt64 &lhs, UInt64 rhs) noexcept
 
constexpr UInt64operator|= (UInt64 &lhs, UInt8 rhs) noexcept
 
constexpr UInt8operator|= (UInt8 &lhs, std::uint8_t rhs) noexcept
 
constexpr UInt8operator|= (UInt8 &lhs, UInt8 rhs) noexcept
 
constexpr UInt16 operator~ (UInt16 value)
 
constexpr UInt32 operator~ (UInt32 value)
 
constexpr UInt64 operator~ (UInt64 value)
 
constexpr UInt8 operator~ (UInt8 value)
 
constexpr auto or_all () noexcept
 
template<typename Value >
constexpr Value or_all (Value value) noexcept
 
template<typename Value , typename... T>
constexpr decltype(autoor_all (Value value, T... values) noexcept
 
template<typename... Funcs>
 overload (Funcs &&...) -> overload< conditional_t< std::is_class_v< daw::remove_cvref_t< Funcs > >, daw::remove_cvref_t< Funcs >, Funcs >... >
 
template<typename Function , typename... Args>
constexpr void pack_apply (std::size_t N, Function &&func, Args &&...args)
 
template<size_t N, std::size_t pos = 0, typename Arg , typename... Args>
constexpr decltype(autopack_get (Arg &&arg, Args &&...args) noexcept
 
template<typename T , typename BitStream >
auto pop_value (BitStream &bs)
 
template<typename T , typename BitStream >
auto pop_value (BitStream &bs, size_t bits_needed)
 
template<typename Iterator >
constexpr Iterator prev (Iterator it, ptrdiff_t n=1) noexcept
 Move iterator backward n steps, if n > 0, only defined for types that are Bidirectional.
 
template<typename... Args>
DAW_ATTRIB_NOINLINE void print (FILE *fout, std::format_string< Args... > fmt, Args &&...args)
 
template<typename... Args>
DAW_ATTRIB_NOINLINE void print (std::format_string< Args... > fmt, Args &&...args)
 
template<typename... Args>
std::ostream & print (std::ostream &os, std::format_string< Args... > fmt, Args &&...args)
 
DAW_ATTRIB_INLINE void println ()
 
template<typename... Args>
DAW_ATTRIB_NOINLINE void println (FILE *f, std::format_string< Args... > fmt, Args &&...args)
 
template<typename... Args>
DAW_ATTRIB_NOINLINE void println (std::format_string< Args... > fmt, Args &&...args)
 
template<typename... Args>
std::ostream & println (std::ostream &os, std::format_string< Args... > fmt, Args &&...args)
 
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void quick_sort (RandomIterator f, RandomIterator l, Compare cmp=Compare{ })
 
template<typename IntType >
IntType randint ()
 
template<typename IntType >
IntType randint (IntType a, IntType b)
 
template<typename IntType , typename ItValueType = IntType, typename ForwardIterator >
void random_fill (ForwardIterator first, ForwardIterator const last, IntType a, IntType b)
 
template<typename CharT = char>
DAW_ATTRIB_NOINLINE std::optional< std::basic_string< CharT > > read_file (std::string const &path) noexcept
 
std::string read_file (std::string const &path, terminate_on_read_file_error_t) noexcept
 
template<typename T , typename = void>
auto ref (T const &value)
 
template<typename T >
auto ref (T const *value)
 
template<typename T = char>
constexpr auto repeat_n_char_end () noexcept
 
template<typename CharT >
 repeat_n_char_iterator (size_t, CharT) -> repeat_n_char_iterator< CharT >
 
void reseed ()
 
void reseed (std::default_random_engine::result_type value)
 
template<typename T >
void return_buffer (T *ptr) noexcept
 
template<typename Iterator >
 reverse_iterator (Iterator) -> reverse_iterator< Iterator >
 
template<typename T , typename Func , typename Compare = daw::graph_alg_impl::NoSort>
void reverse_topological_sorted_walk (daw::graph_t< T > &known_deps, Func visitor, Compare &&comp=Compare{ })
 
template<typename T , typename Func , typename Compare = daw::graph_alg_impl::NoSort>
void reverse_topological_sorted_walk (daw::graph_t< T > const &known_deps, Func visitor, Compare &&comp=Compare{ })
 
template<typename T >
 ring_adaptor (T const &) -> ring_adaptor< T >
 
template<unsigned bits>
constexpr UInt16 rotate_left (UInt16 value)
 
constexpr UInt16 rotate_left (UInt16 value, unsigned bits)
 
template<unsigned bits>
constexpr UInt32 rotate_left (UInt32 value)
 
constexpr UInt32 rotate_left (UInt32 value, unsigned bits)
 
template<unsigned bits>
constexpr UInt64 rotate_left (UInt64 value)
 
constexpr UInt64 rotate_left (UInt64 value, unsigned bits)
 
template<unsigned bits>
constexpr UInt8 rotate_left (UInt8 value)
 
constexpr UInt8 rotate_left (UInt8 value, unsigned bits)
 
template<unsigned bits>
constexpr UInt16 rotate_right (UInt16 value)
 
constexpr UInt16 rotate_right (UInt16 value, unsigned bits)
 
template<unsigned bits>
constexpr UInt32 rotate_right (UInt32 value)
 
constexpr UInt32 rotate_right (UInt32 value, unsigned bits)
 
template<unsigned bits>
constexpr UInt64 rotate_right (UInt64 value)
 
constexpr UInt64 rotate_right (UInt64 value, unsigned bits)
 
template<unsigned bits>
constexpr UInt8 rotate_right (UInt8 value)
 
constexpr UInt8 rotate_right (UInt8 value, unsigned bits)
 
template<typename T >
auto RunIfValid (std::weak_ptr< T > w_ptr)
 
template<typename Container , typename Iterator , typename Distance >
constexpr void safe_advance (Container &container, Iterator &it, Distance distance) noexcept
 Advance Iterator within the bounds of container.
 
template<typename Container , typename Iterator , typename Distance >
constexpr void safe_advance (Container const &container, Iterator &it, Distance distance) noexcept
 Advance Iterator within the bounds of container.
 
template<typename Iterator , typename Distance = size_t>
constexpr Iterator safe_next (Iterator it, Iterator const last, Distance n=1U) noexcept(noexcept(daw::next(it, static_cast< std::ptrdiff_t >(n))))
 Advance iterator n steps forward but do not go past last. Undefined if it > last.
 
template<typename Iterator , typename Distance >
constexpr Iterator safe_prev (Iterator it, Iterator first, Distance n=1) noexcept(noexcept(daw::prev(it, static_cast< std::ptrdiff_t >(n))))
 Advance iterator n steps backward but do not go past first. Undefined if it < first.
 
template<unsigned N>
constexpr void set_bit (UInt16 &value, bool state)
 
template<unsigned N>
constexpr void set_bit (UInt32 &value, bool state)
 
template<unsigned N>
constexpr void set_bit (UInt64 &value, bool state)
 
template<unsigned N>
constexpr void set_bit (UInt8 &value, bool state)
 
template<typename Integer , typename Bit , typename... Bits>
constexpr Integer set_bits (Integer i, Bit b, Bits... bs) noexcept
 set bits at positions specified by b,bs...
 
template<typename Func >
DAW_ATTRIB_NOINLINE void show_benchmark (size_t data_size_bytes, std::string const &title, Func &&func, size_t data_prec=1, size_t time_prec=0, size_t item_count=1)
 
template<typename RandomIterator >
void shuffle (RandomIterator first, RandomIterator last)
 
template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool signbit (T t)
 
template<typename T , typename... Ts>
 simple_array (T &&, Ts &&...) -> simple_array< T, sizeof...(Ts)+1 >
 
template<typename Byte >
constexpr uint64_t siphash24 (Byte const *first, size_t sz, Byte const *const key)
 
template<typename Container >
constexpr auto size (Container const &c) noexcept(noexcept(c.size())) -> decltype(c.size())
 
template<typename BitStream >
void skip_bits (BitStream &bs, size_t bits_needed)
 
template<typename BitStream >
void skip_bytes (BitStream &bs, size_t bytes_needed)
 
template<typename BitStream , typename TestValue >
void skip_until (BitStream &bs, TestValue const &v)
 
template<typename BitStream , typename TestValue >
void skip_until (BitStream &bs, TestValue const &v, size_t bit_count)
 
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void sort (RandomIterator first, RandomIterator last, Compare &&comp=Compare{ }) noexcept(sort_n_details::is_nothrow_sortable_v< RandomIterator, Compare >)
 
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void sort_16 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
 
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void sort_3 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
 
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void sort_32 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
 
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void sort_4 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
 
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void sort_5 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
 
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void sort_6 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
 
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void sort_7 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
 
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void sort_8 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
 
template<typename ForwardIterator , typename RandomOutputIterator , typename Compare = std::less<>, std::enable_if_t< std::is_integral_v< typename std::iterator_traits< ForwardIterator >::value_type >, std::nullptr_t > = nullptr>
constexpr RandomOutputIterator sort_to (ForwardIterator first_in, ForwardIterator last_in, RandomOutputIterator first_out, Compare &&comp=Compare{ })
 
template<typename InputIterator , typename RandomOutputIterator , typename Compare = std::less<>, std::enable_if_t< not std::is_integral_v< typename std::iterator_traits< InputIterator >::value_type >, std::nullptr_t > = nullptr>
constexpr RandomOutputIterator sort_to (InputIterator first_in, InputIterator last_in, RandomOutputIterator first_out, Compare &&comp=Compare{ })
 
template<typename Container >
 span (Container &) -> span< std::remove_reference_t< decltype(*std::data(std::declval< Container >()))> >
 
template<typename Container >
 span (Container const &) -> span< DAW_TYPEOF(*std::data(std::declval< Container >())) const >
 
template<typename T >
 span (T *, size_t) -> span< T >
 
template<typename T >
 span (T *, T *) -> span< T >
 
template<typename T >
 span (T *, T const *) -> span< T >
 
template<typename T , size_t N>
 span (T const (&)[N]) -> span< T const >
 
template<typename T >
 span (T const *, size_t) -> span< T const >
 
template<typename T >
 span (T const *, T *) -> span< T const >
 
template<typename T >
 span (T const *, T const *) -> span< T const >
 
template<typename T , size_t N>
 span (T(&)[N]) -> span< T >
 
template<typename CharT , size_t Capacity, size_t N>
auto split (daw::basic_bounded_string< CharT, Capacity > &&str, CharT const (&delemiter)[N])=delete
 
template<typename CharT , size_t Capacity>
auto split (daw::basic_bounded_string< CharT, Capacity > &&str, CharT const delemiter)=delete
 
template<typename CharT , size_t Capacity, size_t N>
auto split (daw::basic_bounded_string< CharT, Capacity > const &str, CharT const (&delemiter)[N])
 
template<typename CharT , size_t Capacity>
auto split (daw::basic_bounded_string< CharT, Capacity > const &str, CharT const delemiter)
 
template<typename CharT , size_t N, typename UnaryPredicate >
auto split (daw::basic_bounded_string< CharT, N > &&str, UnaryPredicate pred)=delete
 
template<typename CharT , size_t N, typename UnaryPredicate >
auto split (daw::basic_bounded_string< CharT, N > const &str, UnaryPredicate pred)
 
template<std::size_t StartN, std::size_t EndN, typename... Args, std::enable_if_t<(sizeof...(Args) >=EndN), std::nullptr_t > = nullptr>
constexpr auto split_args (std::tuple< Args... > args)
 
template<std::size_t StartN, typename... Args, std::size_t... Is, std::enable_if_t<(sizeof...(Args) >=(sizeof...(Is)+StartN)), std::nullptr_t > = nullptr>
constexpr auto split_args_impl (std::tuple< Args... > &&args, std::index_sequence< Is... >)
 
template<typename CharT , typename Bounds = daw::sv1::default_string_view_bounds_type, size_t N, size_t M>
constexpr string_split_range< CharT > split_string (CharT const (&str)[N], CharT const (&delemiter)[M]) noexcept
 
template<typename CharT >
constexpr string_split_range< CharT > split_string (daw::sv1::basic_string_view< CharT > str, daw::sv1::basic_string_view< CharT > delemiter) noexcept
 
template<typename CharT , typename Bounds , std::ptrdiff_t Ex, size_t N>
constexpr string_split_range< CharT > split_string (daw::sv1::basic_string_view< CharT, Bounds, Ex > str, CharT const (&delemiter)[N]) noexcept
 
template<typename CharT , daw::sv2::string_view_bounds_type Bounds, std::ptrdiff_t Ex, size_t N>
constexpr string_split_range< CharT > split_string (daw::sv2::basic_string_view< CharT, Bounds > str, CharT const (&delemiter)[N]) noexcept
 
template<typename CharT >
string_split_range< CharT > split_string (std::basic_string< CharT > const &str, daw::sv1::basic_string_view< CharT > delemiter) noexcept
 
template<typename CharT >
string_split_range< CharT > split_string (std::basic_string< CharT > const &str, std::basic_string< CharT > &delemiter) noexcept
 
template<typename... Strings>
std::string string_concat (std::string arg, Strings &&...strings)
 
template<typename CharT >
 string_split_iterator (daw::sv1::basic_string_view< CharT >, daw::sv1::basic_string_view< CharT >) -> string_split_iterator< CharT >
 
template<typename CharT >
 string_split_range (daw::sv1::basic_string_view< CharT >, daw::sv1::basic_string_view< CharT >) -> string_split_range< CharT >
 
template<typename CharT , size_t N>
constexpr void swap (basic_bounded_string< CharT, N > &lhs, basic_bounded_string< CharT, N > &rhs) noexcept
 
template<typename T , size_t N>
constexpr void swap (carray< T, N > &lhs, carray< T, N > &rhs) noexcept(std::is_nothrow_move_assignable_v< T >)
 
template<class T1 , class T2 >
constexpr void swap (compressed_pair< T1, T2 > &x, compressed_pair< T1, T2 > &y) noexcept(std::is_nothrow_swappable_v< T1 > and std::is_nothrow_swappable_v< T2 >)
 
template<typename T , typename Deleter >
constexpr void swap (copiable_unique_ptr< T, Deleter > &lhs, copiable_unique_ptr< T, Deleter > &rhs) noexcept
 
template<typename... Args>
void swap (CString< Args... > &lhs, CString< Args... > &rhs) noexcept
 
template<typename T >
constexpr void swap (daw::heap_array< T > &lhs, daw::heap_array< T > &rhs) noexcept
 
template<typename T >
void swap (daw::optional_poly< T > &lhs, daw::optional_poly< T > &rhs) noexcept
 
template<typename T >
void swap (hash_table< T > &lhs, hash_table< T > &rhs) noexcept
 
template<typename T >
void swap (hash_table_item_iterator< T > &lhs, hash_table_item_iterator< T > &rhs) noexcept
 
template<typename T >
void swap (heap_value< T > &lhs, heap_value< T > &rhs) noexcept
 
template<typename T , typename D >
constexpr void swap (rc_ptr< T, D > &lhs, rc_ptr< T, D > &rhs)
 
template<class T , class Allocator >
constexpr void swap (split_buffer< T, Allocator > &x, split_buffer< T, Allocator > &y) noexcept(noexcept(x.swap(y)))
 
template<typename T >
constexpr void swap (value_ptr< T > &lhs, value_ptr< T > &rhs) noexcept(noexcept(lhs.swap(rhs)))
 
template<typename T , typename Allocator >
constexpr void swap (vector< T, Allocator > &x, vector< T, Allocator > &y) noexcept(noexcept(x.swap(y)))
 
template<typename ForwardIterator1 , typename ForwardIterator2 >
constexpr ForwardIterator2 swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2) noexcept(noexcept(daw::iter_swap(first1, first2)))
 
template<typename T , std::enable_if_t< std::is_default_constructible_v< T >, std::nullptr_t > = nullptr>
constexprtake (T &value) noexcept(std::is_nothrow_move_constructible_v< T > and std::is_nothrow_default_constructible_v< T >)
 
template<typename... Ts>
constexpr tuple< Ts &... > tie (Ts &...ts) noexcept
 
template<typename T >
constexpr T * to_address (T *p) noexcept
 
template<typename T >
constexpr auto to_address (T const &p) noexcept
 
template<typename T , std::size_t N>
constexpr std::array< std::remove_cv_t< T >, Nto_array (T(&a)[N])
 
template<typename To , typename From >
auto to_array_of (From &&from) noexcept
 
template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>
constexprto_big_endian (T value) noexcept
 
template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>
constexprto_little_endian (T value) noexcept
 
template<endian SourceEndian, typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>
constexprto_native_endian (T value) noexcept
 
template<typename CharT , typename OutputIterator , typename Integer , typename Traits = daw::impl::char_traits<CharT>, std::enable_if_t< can_to_os_string_int_v< daw::remove_cvref_t< Integer > >, std::nullptr_t > = nullptr>
constexpr OutputIterator to_os_string_int (OutputIterator it, Integer value)
 
template<typename Iterator >
auto to_reference_vector (Iterator first, Iterator last)
 
template<typename Char >
std::string to_string (CString< Char > const &str)
 
template<size_t BitWidth>
std::string to_string (static_bitset< BitWidth > const &bs)
 
template<typename Number >
constexpr UInt16 to_uint16 (Number num)
 
template<typename CharT , std::enable_if_t<(sizeof(CharT)==1), std::nullptr_t > = nullptr>
constexpr UInt16 to_uint16_buffer (CharT const *ptr) noexcept
 
template<typename Number >
constexpr UInt32 to_uint32 (Number num)
 
template<typename CharT , std::enable_if_t<(sizeof(CharT)==1), std::nullptr_t > = nullptr>
constexpr UInt32 to_uint32_buffer (CharT const *ptr) noexcept
 
template<typename Number >
constexpr UInt64 to_uint64 (Number num)
 
template<typename CharT , std::enable_if_t<(sizeof(CharT)==1), std::nullptr_t > = nullptr>
constexpr UInt64 to_uint64_buffer (CharT const *ptr) noexcept
 
template<typename Number >
constexpr UInt8 to_uint8 (Number num)
 
template<typename Enum , std::enable_if_t< std::is_enum_v< Enum >, std::nullptr_t > = nullptr>
constexpr auto to_underlying (Enum e)
 
template<typename T , typename Function , typename Compare = daw::graph_alg_impl::NoSort>
void topological_sorted_walk (daw::graph_t< T > &graph, Function &&func, Compare comp=Compare{ })
 
template<typename T , typename Function , typename Compare = daw::graph_alg_impl::NoSort>
void topological_sorted_walk (daw::graph_t< T > const &graph, Function &&func, Compare comp=Compare{ })
 
template<typename Map , typename Key >
constexpr auto try_get (Map &container, Key &&k)
 
template<typename Map , typename Key >
constexpr auto try_get (Map const &container, Key &&k)
 
template<typename... Ts>
 tuple (Ts...) -> tuple< Ts... >
 
template<typename... Ts>
 tuple2 (Ts...) -> tuple2< Ts... >
 
constexpr tuple2 tuple2_cat ()
 
template<typename T0 , typename T1 , typename... Tps>
constexpr auto tuple2_cat (T0 &&t0, T1 &&t1, Tps &&...tps)
 
template<typename Tuple >
constexpr tuple2 tuple2_cat (Tuple &&tp)
 
template<typename Integer , typename Bit , typename... Bits>
constexpr Integer unset_bits (Integer i, Bit b, Bits... bs) noexcept
 set bits at positions specified by b,bs...
 
template<typename To >
constexpr uint16_t value_from_chars (unsigned char const *ptr, std::integral_constant< size_t, sizeof(uint16_t)>) noexcept
 
template<typename To >
constexpr uint32_t value_from_chars (unsigned char const *ptr, std::integral_constant< size_t, sizeof(uint32_t)>) noexcept
 
template<typename To >
constexpr uint64_t value_from_chars (unsigned char const *ptr, std::integral_constant< size_t, sizeof(uint64_t)>) noexcept
 
template<typename To >
constexpr uint8_t value_from_chars (unsigned char const *ptr, std::integral_constant< size_t, sizeof(uint8_t)>) noexcept
 
template<typename T >
constexpr auto value_is (T &&value) -> daw::utility_details::value_is_utility_details< std::remove_reference_t< decltype(value)> >
 
template<typename... Args, typename Stream >
decltype(autovalues_from_stream (Stream &&s, daw::string_view delemiter)
 Extract specified argument types from a stream of character data.
 
template<typename... Args, typename Stream , typename Splitter , std::enable_if_t<(not parse_to_impl::has_str_member_v< Stream > and std::is_invocable_v< Splitter, daw::string_view >), std::nullptr_t > = nullptr>
decltype(autovalues_from_stream (Stream &&stream, Splitter &&splitter)
 Extract specified argument types from a stream of character data.
 
template<typename T , typename... Args>
constexprvariant_cast (std::variant< Args... > &&var)
 
template<typename T , typename... Args>
constexprvariant_cast (std::variant< Args... > &var)
 
template<typename T , typename... Args>
constexprvariant_cast (std::variant< Args... > const &var)
 
template<input_iterator InputIterator>
 vector (InputIterator, InputIterator) -> vector< iter_value_type< InputIterator >, std::allocator< iter_value_type< InputIterator > > >
 
template<input_iterator InputIterator, Allocators Alloc>
 vector (InputIterator, InputIterator, Alloc) -> vector< iter_value_type< InputIterator >, Alloc >
 
template<typename T , std::size_t N>
 Vector (T const (&)[N]) -> Vector< T >
 
template<typename BidirectionalIterator >
 view (BidirectionalIterator, BidirectionalIterator) -> view< BidirectionalIterator >
 
template<typename Variant , typename... Visitors>
constexpr decltype(autovisit (Variant &&var, Visitors &&...visitors)
 
template<typename Result , typename Variant , typename... Visitors>
constexpr Result visit (Variant &&var, Visitors &&...visitors)
 
template<typename Variant , typename... Visitors>
constexpr decltype(autovisit_nt (Variant &&var, Visitors &&...visitors)
 
template<typename Result , typename Variant , typename... Visitors>
constexpr Result visit_nt (Variant &&var, Visitors &&...visitors)
 
template<typename... Args>
DAW_ATTRIB_NOINLINE void vprint (FILE *fout, std::string_view fmt, Args &&...args)
 
template<typename... Args>
DAW_ATTRIB_NOINLINE void vprint (std::string_view fmt, Args &&...args)
 
template<typename... Args>
DAW_ATTRIB_NOINLINE void vprintln (FILE *f, std::string fmt, Args &&...args)
 
template<typename... Args>
DAW_ATTRIB_NOINLINE void vprintln (std::string fmt, Args &&...args)
 
template<typename... Containers>
 zip_container (Containers &&...) -> zip_container< Containers... >
 
template<typename... Iterators>
 zip_iterator (Iterators...) -> zip_iterator< Iterators... >
 

Variables

template<bool... values>
constexpr bool all_true_v = ( values and ... )
 
template<typename... Ts>
constexpr bool always_false_v = always_false<Ts...>::value
 
template<auto needle, auto... needles>
static constexpr any_of_t< decltype(needle), needle, needles... > any_of { }
 A predicate value used in the find based routine to return true when the element is one of the specified characters.
 
template<bool... values>
constexpr bool any_true_v = ( values or ... )
 
template<typename T >
constexpr std::size_t bit_count_v = sizeof( T ) * CHAR_BIT
 
template<typename T >
constexpr std::size_t const bsizeof
 
template<size_t N, typename Invokable , typename TpArgs , typename... Args>
constexpr bool can_call_v
 
template<DAW_CXEVAL_FTYPE F>
constexpr bool can_constant_evaluate_v
 
template<typename T , typename... Args>
constexpr bool can_construct_a_v
 
template<typename T , typename... Args>
constexpr bool can_potentially_constant_construct_v
 
template<typename Integer >
constexpr bool can_to_os_string_int_v
 
template<typename... Ts>
constexpr bool conjunction_v
 
template<decltype(auto) Value>
constexpr auto constant_v = constant<Value>{ }
 
template<typename T >
constexpr construct_a_t< T > construct_a = construct_a_t<T>{ }
 
template<typename T = void>
constexpr construct_emplace_t< T > construct_emplace { }
 
constexpr construct_for_overwrite_t construct_for_overwrite { }
 
static constinit thread_local daw::function_ref< void()> contract_failure_handler = default_contract_failure
 
template<typename... >
constexpr bool deduced_false_v = false
 
template<typename... >
constexpr bool dependent_false_v = false
 
template<typename T >
constexpr daw::string_view describe_v = impl::describe_impl<T>( )
 
template<typename T >
constexpr auto digits = numeric_limits<T>::digits
 
template<typename T >
constexpr auto digits10 = numeric_limits<T>::digits10
 
constexpr auto discard = discard_t{ }
 
template<typename... Ts>
constexpr bool disjunction_v
 
constexpr auto do_resize_and_overwrite = do_resize_and_overwrite_t{ }
 
constexpr auto dont_clip_to_bounds = dont_clip_to_bounds_t{ }
 
constexpr auto DynamicExtent = max_value<std::size_t>
 
constexpr bitset_impl::fmt_binary_t const fmt_binary { }
 
constexpr bitset_impl::fmt_decimal_t const fmt_decimal { }
 
constexpr bitset_impl::fmt_hex_t const fmt_hex { }
 
template<typename Container >
constexpr bool has_kv_mapping_v
 Specifies that Container has type alias members key_type and mapped_type.
 
template<typename T >
constexpr bool has_slow_distance_v
 
template<std::size_t N>
constexpr index_constant< Nindex_constant_v = index_constant<N>{ }
 
template<auto Needle, auto... Haystack>
constexpr bool is_any_of_v = ( ( Needle == Haystack ) or ... )
 
template<typename T >
constexpr bool is_arithmetic_v
 
constexpr auto is_ascii_alpha = is_ascii_alpha_t{ }
 
constexpr auto is_ascii_alphanum = is_ascii_alphanum_t{ }
 
constexpr auto is_ascii_digit = is_ascii_digit_t{ }
 
constexpr auto is_ascii_printable = is_ascii_printable_t{ }
 
template<typename T >
constexpr bool is_bounded_graph_node_v = false
 
template<typename T , size_t MaxVerticesPerNode, typename Hash >
constexpr bool is_bounded_graph_node_v< bounded_graph_node_t< T, MaxVerticesPerNode, Hash > >
 
template<typename T , size_t MaxVerticesPerNode, typename Hash >
constexpr bool is_bounded_graph_node_v< const_graph_node_t< T, MaxVerticesPerNode, Hash > >
 
template<typename T >
constexpr bool is_complete_type_v
 
template<typename T >
constexpr bool const is_daw_span_v = is_daw_span_t<T>::value
 
template<typename T >
constexpr bool is_deduced_type_v = false
 
template<>
constexpr bool is_deduced_type_v< deduced_type > = true
 
template<typename To , template< typename... > typename Op, typename... Args>
constexpr bool is_detected_convertible_v
 
template<typename Expected , template< typename... > typename Op, typename... Args>
constexpr bool is_detected_exact_v
 
template<template< typename... > typename Op, typename... Args>
constexpr bool is_detected_v
 
template<typename Tuple >
constexpr bool is_empty_tuple_v = ( tuple_size_v<Tuple> == 0 )
 
template<typename T >
constexpr bool is_floating_point_v
 
template<typename >
constexpr bool is_graph_node_v = false
 
template<typename T >
constexpr bool is_graph_node_v< const_graph_node_t< T > > = true
 
template<typename T >
constexpr bool is_graph_node_v< graph_node_t< T > > = true
 
template<typename T >
constexpr bool is_integral_v = daw::numeric_limits<T>::is_integer
 
template<typename Alloc , typename = void>
constexpr bool is_move_insertable_v
 
template<typename >
constexpr bool is_nonesuch_v = false
 
template<template< class... > class Op, class... Args>
constexpr bool is_nonesuch_v< nonesuch< Op, Args... > > = true
 
template<size_t N, typename Invokable , typename TpArgs , typename... Args>
constexpr bool is_nothrow_callable_v
 
template<typename From , typename To >
constexpr bool is_nothrow_convertible_v
 
template<typename T >
constexpr bool is_number_v
 
template<typename >
constexpr bool is_reference_wrapper_v = false
 
template<typename T , std::size_t BitSize>
constexpr bool is_same_size_v = is_same_size<T, BitSize>::value
 
template<typename T , typename U >
constexpr bool is_same_v = false
 
template<typename T >
constexpr bool is_same_v< T, T > = true
 
template<typename T >
constexpr bool is_signed_v
 
template<template< typename... > typename Primary, typename T >
constexpr bool is_specialization_of_v = false
 
template<template< typename... > typename Primary, typename... Args>
constexpr bool is_specialization_of_v< Primary, Primary< Args... > >
 
template<typename T >
constexpr bool is_swappable_v = std::is_swappable_v<T>
 
template<typename T >
constexpr bool is_system_integral_v = is_system_integral<T>::value
 
template<typename >
constexpr bool is_tuple2_v = false
 
template<typename... Ts>
constexpr bool is_tuple2_v< tuple2< Ts... > > = true
 
template<typename Tp , typename = void>
constexpr bool is_tuple_like_v = false
 
template<typename >
constexpr bool is_tuple_v = false
 
template<typename T >
constexpr bool is_unbounded_array_v = false
 
template<typename T >
constexpr bool is_unbounded_array_v< T[]> = true
 
template<typename T >
constexpr bool is_unsigned_v
 
template<typename Value , typename... Visitors>
constexpr bool is_visitable_v
 
template<auto fp>
constexpr overload_details::lift_t< fp > lift
 
template<typename T >
constexpr auto lowest_value = numeric_limits<T>::lowest( )
 
template<unsigned N>
constexpr UInt16 mask_from_lsb16
 
template<unsigned N>
constexpr UInt32 mask_from_lsb32
 
template<unsigned N>
constexpr UInt64 mask_from_lsb64
 
template<unsigned N>
constexpr UInt8 mask_from_lsb8
 
template<typename T >
constexpr auto max_digits10 = numeric_limits<T>::max_digits10
 
template<typename T >
constexpr auto max_value = numeric_limits<T>::max( )
 
template<typename T >
constexpr auto min_value = numeric_limits<T>::min( )
 
constexpr never_null_t never_null = never_null_t{ }
 
constexpr auto nodiscard = nodiscard_t{ }
 
template<auto needle, auto... needles>
static constexpr none_of_t< decltype(needle), needle, needles... > none_of { }
 
template<typename T >
constexprnot_null_null_value = T{ }
 
template<typename T >
constexpr T * not_null_null_value< T * > = nullptr
 
constexpr std::nullopt_t nullopt = std::nullopt
 
template<typename T , typename... Ts>
constexpr auto pack_index_of_v
 
template<typename Pack >
constexpr auto pack_size_v = deleted<Pack>
 
template<template< typename... > typename Pack, typename... Ts>
constexpr std::size_t pack_size_v< Pack< Ts... > > = sizeof...( Ts )
 
template<typename T , typename >
constexpr auto param_pack_index_of_v = deleted<T>
 
template<template< typename... > typename Pack, typename... Ts, typename T >
constexpr std::size_t param_pack_index_of_v< Pack< Ts... >, T >
 
template<typename T >
constexpr bool reset_on_take = true
 
constexpr sized_for_overwrite_t sized_for_overwrite
 
template<typename... Args>
constexpr tag_t< Args... > tag = tag_t<Args...>{ }
 
constexpr take_ownership_t take_ownership { }
 
template<typename T >
constexpr template_param< T > template_arg = template_param<T>{ }
 
template<typename... Ts>
constexpr template_params< Ts... > template_args
 
template<auto... vals>
constexpr template_vals_t< vals... > template_vals
 
constexpr auto terminate_on_read_file_error
 
constexpr auto to_lower_ascii = to_lower_ascii_t{ }
 
constexpr auto to_upper_ascii = to_upper_ascii_t{ }
 
template<typename T >
static constexpr std::size_t tuple2_size_v = tuple2_size<T>::value
 
template<typename Tuple >
constexpr size_t tuple_size_v
 
template<typename T >
constexpr auto undefined_v = impl::undefind_fn_t<T>{ }
 

Detailed Description

Provides structs for wrapping function pointers and callable objects to facilitate function overloading and safe invocation.

formatter will directly substitute variables into a string Uses a format like "{0} {1} {0}" which is a zero index array of the arguments

Provide a class to validate a type T after construction Validator must return true if the value is valid, false otherwise.

Provides utilities for working with parameter packs in templates.

Typedef Documentation

◆ aligned_storage_for_t

template<typename T , typename... Ts>
using daw::aligned_storage_for_t = typedef typename impl::aligned_storage<std::max( { sizeof( T ), sizeof( Ts )... } ), std::max( { alignof( T ), alignof( Ts )... } )>::type

Definition at line 29 of file daw_aligned_storage.h.

◆ aligned_storage_t

template<std::size_t Size, std::size_t Align = alignof( std::max_align_t )>
using daw::aligned_storage_t = typedef typename impl::aligned_storage<Size, Align>::type

Definition at line 26 of file daw_aligned_storage.h.

◆ all_true

template<bool... values>
using daw::all_true = typedef std::bool_constant<( values and ... )>

Definition at line 46 of file cpp_17.h.

◆ any_true

template<bool... values>
using daw::any_true = typedef std::bool_constant<( values or ... )>

Definition at line 52 of file cpp_17.h.

◆ bad_variant_access

using daw::bad_variant_access = typedef std::bad_variant_access

Definition at line 30 of file daw_visit.h.

◆ bit_queue

Definition at line 135 of file daw_bit_queues.h.

◆ bit_queue_source_native_endian

Definition at line 26 of file daw_bit_queues.h.

◆ bool_constant

template<bool B>
using daw::bool_constant = typedef std::bool_constant<B>

Definition at line 27 of file cpp_17.h.

◆ bounded_array_t

Definition at line 116 of file daw_bounded_array.h.

◆ bounded_string

Definition at line 753 of file daw_bounded_string.h.

◆ can_call_test

template<typename N , typename Invokable , typename TpArgs , typename... Args>
using daw::can_call_test = typedef std::is_invocable< applier_t<Invokable>, decltype( std::tuple_cat( split_args<0, N::value>( std::forward_as_tuple( DAW_FWD( std::declval<Args>( ) )... ) ), std::declval<TpArgs>( ), split_args<N::value, sizeof...( Args )>( std::forward_as_tuple( DAW_FWD( std::declval<Args>( ) )... ) ) ) )>

Definition at line 73 of file daw_bind_args_at.h.

◆ can_constant_evaluate

template<DAW_CXEVAL_FTYPE F>
using daw::can_constant_evaluate = typedef typename decltype( can_cxeval_impl::can_cxeval<F>( ) )::type

Definition at line 70 of file daw_can_constant_evaluate.h.

◆ can_potentially_constant_construct

template<typename T , typename... Args>
using daw::can_potentially_constant_construct = typedef typename conditional_t< ( std::is_default_constructible_v<Args> and ... ), can_cxeval_impl::can_potentially_constant_construct_impl<T, Args...>, daw::traits::identity<std::false_type> >::type

Definition at line 82 of file daw_can_constant_evaluate.h.

◆ clumpy_sparsy_const_iterator

Definition at line 27 of file daw_clumpy_sparsy.h.

◆ common_iterator_category_t

template<typename... Its>
using daw::common_iterator_category_t = typedef daw::remove_cvref_t< decltype( iterator_traits_impl::common_iterator_tag_test_t< std::index_sequence_for<Its...> >:: test( std::declval<Its const &>( )... ) )>

Definition at line 161 of file daw_iterator_traits.h.

◆ conditional_t

Definition at line 30 of file daw_traits_conditional.h.

◆ conjunction

template<typename... Ts>
using daw::conjunction = typedef conjunction_t<Ts...>

Definition at line 40 of file cpp_17.h.

◆ conjunction_t

template<typename... Ts>
using daw::conjunction_t = typedef std::bool_constant<conjunction_v<Ts...> >

Definition at line 37 of file cpp_17.h.

◆ const_iterator_end_t

template<Range R>
using daw::const_iterator_end_t = typedef DAW_TYPEOF( std::cend( std::declval<R const &>( ) ) )

Definition at line 183 of file daw_iterator_traits.h.

◆ const_iterator_t

template<Range R>
using daw::const_iterator_t = typedef DAW_TYPEOF( std::cbegin( std::declval<R const &>( ) ) )

Definition at line 179 of file daw_iterator_traits.h.

◆ cstring

Definition at line 175 of file daw_cstring.h.

◆ detected_or

template<typename Default , template< typename... > typename Op, typename... Args>
using daw::detected_or = typedef is_detect_details::detector<Default, void, Op, Args...>

Definition at line 108 of file daw_is_detected.h.

◆ detected_or_t

template<typename Default , template< typename... > typename Op, typename... Args>
using daw::detected_or_t = typedef typename detected_or<Default, Op, Args...>::type

Definition at line 112 of file daw_is_detected.h.

◆ detected_t

template<template< typename... > typename Op, typename... Args>
using daw::detected_t = typedef typename is_detect_details::detector<nonesuch<Op, Args...>, void, Op, Args...>::type

Definition at line 96 of file daw_is_detected.h.

◆ disjunction

template<typename... Ts>
using daw::disjunction = typedef disjunction_t<Ts...>

Definition at line 164 of file cpp_17.h.

◆ disjunction_t

template<typename... Ts>
using daw::disjunction_t = typedef std::bool_constant<disjunction_v<Ts...> >

Definition at line 161 of file cpp_17.h.

◆ Empty

Definition at line 13 of file daw_empty.h.

◆ enable_copy_assignment

template<typename T , bool B = true>
using daw::enable_copy_assignment = typedef traits_details::delete_copy_assignment_if< not std::is_copy_assignable_v<T> and B>

Definition at line 445 of file daw_traits_impl.h.

◆ enable_copy_constructor

template<typename T , bool B = true>
using daw::enable_copy_constructor = typedef traits_details::delete_copy_constructor_if< not std::is_copy_constructible_v<T> and B>

Definition at line 441 of file daw_traits_impl.h.

◆ enable_default_constructor

template<typename T , bool B = true>
using daw::enable_default_constructor = typedef traits_details::delete_default_constructor_if< not std::is_default_constructible_v<T> and B>

Definition at line 436 of file daw_traits_impl.h.

◆ enable_if

template<bool B, typename T = std::nullptr_t>
using daw::enable_if = typedef std::enable_if<B, T>

Definition at line 19 of file daw_enable_if.h.

◆ enable_if_t

template<bool B, typename T = std::nullptr_t>
using daw::enable_if_t = typedef std::enable_if_t<B, T>

Definition at line 22 of file daw_enable_if.h.

◆ enable_move_assignment

template<typename T , bool B = true>
using daw::enable_move_assignment = typedef traits_details::delete_move_assignment_if< not std::is_move_assignable_v<T> and B>

Definition at line 453 of file daw_traits_impl.h.

◆ enable_move_constructor

template<typename T , bool B = true>
using daw::enable_move_constructor = typedef traits_details::delete_move_constructor_if< not std::is_move_constructible_v<T> and B>

Definition at line 449 of file daw_traits_impl.h.

◆ enable_when_all_t

template<typename... Traits>
using daw::enable_when_all_t = typedef enable_if_t<std::conjunction_v<Traits...> >

Definition at line 28 of file daw_enable_if.h.

◆ enable_when_t

template<bool... B>
using daw::enable_when_t = typedef enable_if_t<( B && ... )>

Definition at line 25 of file daw_enable_if.h.

◆ enough_args_t

template<size_t N, typename TpArgs , typename... Args>
using daw::enough_args_t = typedef std::bool_constant<( (sizeof...( Args ) + std::tuple_size_v<TpArgs>) >= N )>

Definition at line 69 of file daw_bind_args_at.h.

◆ fn_t

template<typename T >
using daw::fn_t = typedef std::add_pointer_t<T>

Definition at line 30 of file InputIterator.h.

◆ fnv1a_uint_t

using daw::fnv1a_uint_t = typedef conditional_t<fnv1a_impl::is_64bit_v, std::uint64_t, std::uint32_t>

Definition at line 35 of file daw_fnv1a_hash.h.

◆ fp_t

template<typename T >
using daw::fp_t = typedef T *

Definition at line 938 of file daw_traits.h.

◆ function_pointer_t

template<typename ResultType , typename... ArgTypes>
using daw::function_pointer_t = typedef typename utility_details::make_function_pointer_impl<ResultType, ArgTypes...>::type

Definition at line 73 of file daw_utility.h.

◆ function_traits_t

Definition at line 196 of file daw_utility.h.

◆ genhash_uint_t

Definition at line 27 of file daw_generic_hash.h.

◆ if_else_t

Definition at line 308 of file daw_traits_impl.h.

◆ if_t

template<bool Bool_, typename If_ , typename Then_ >
using daw::if_t = typedef typename std::conditional<Bool_, If_, Then_>::type

Definition at line 933 of file daw_utility.h.

◆ ignore_one_t

Definition at line 967 of file daw_traits.h.

◆ index_constant

template<std::size_t N>
using daw::index_constant = typedef std::integral_constant<std::size_t, N>

Definition at line 847 of file daw_traits.h.

◆ intN_t

Definition at line 205 of file daw_arith_traits.h.

◆ is_arithmetic

template<typename T >
using daw::is_arithmetic = typedef std::bool_constant<is_arithmetic_v<T> >

Definition at line 85 of file daw_arith_traits.h.

◆ is_complete_type

template<typename T >
using daw::is_complete_type = typedef std::bool_constant<is_complete_type_v<T> >

Definition at line 914 of file daw_traits.h.

◆ is_detected

template<template< typename... > typename Op, typename... Args>
using daw::is_detected = typedef typename is_detect_details::detector<nonesuch<Op, Args...>, void, Op, Args...>::value_t

Definition at line 91 of file daw_is_detected.h.

◆ is_detected_convertible

template<typename To , template< typename... > typename Op, typename... Args>
using daw::is_detected_convertible = typedef std::is_convertible<detected_t<Op, Args...>, To>

Definition at line 125 of file daw_is_detected.h.

◆ is_detected_exact

template<typename Expected , template< typename... > typename Op, typename... Args>
using daw::is_detected_exact = typedef std::bool_constant<is_detected_exact_v<Expected, Op, Args...> >

Definition at line 121 of file daw_is_detected.h.

◆ is_floating_point

template<typename T >
using daw::is_floating_point = typedef std::bool_constant<is_floating_point_v<T> >

Definition at line 41 of file daw_arith_traits.h.

◆ is_integral

template<typename T >
using daw::is_integral = typedef std::bool_constant<is_integral_v<T> >

Definition at line 30 of file daw_arith_traits.h.

◆ is_number

template<typename T >
using daw::is_number = typedef std::bool_constant<is_number_v<T> >

Definition at line 51 of file daw_arith_traits.h.

◆ is_reference_wrapper

template<typename T >
using daw::is_reference_wrapper = typedef std::bool_constant<is_reference_wrapper_v<T> >

Definition at line 105 of file cpp_17.h.

◆ is_same

template<typename T , typename U >
using daw::is_same = typedef std::bool_constant<is_same_v<T, U> >

Definition at line 21 of file daw_traits_is_same.h.

◆ is_same_size

template<typename T , std::size_t BitSize>
using daw::is_same_size = typedef std::bool_constant<( bit_count_v<T> == BitSize )>

Definition at line 196 of file daw_arith_traits.h.

◆ is_same_t

template<typename T , typename U >
using daw::is_same_t = typedef typename std::bool_constant<is_same_v<T, U> >::type

Definition at line 24 of file daw_traits_is_same.h.

◆ is_signed

template<typename T >
using daw::is_signed = typedef std::bool_constant<is_signed_v<T> >

Definition at line 62 of file daw_arith_traits.h.

◆ is_specialization_of

template<template< typename... > typename Primary, typename T >
using daw::is_specialization_of = typedef std::bool_constant<is_specialization_of_v<Primary, T> >

Definition at line 890 of file daw_traits.h.

◆ is_tuple

template<typename T >
using daw::is_tuple = typedef std::bool_constant<is_tuple_v<T> >

Definition at line 22 of file daw_tuple_traits.h.

◆ is_unbounded_array

template<typename T >
using daw::is_unbounded_array = typedef std::bool_constant<is_unbounded_array_v<T> >

Definition at line 57 of file cpp_20.h.

◆ is_unsigned

template<typename T >
using daw::is_unsigned = typedef std::bool_constant<is_unsigned_v<T> >

Definition at line 73 of file daw_arith_traits.h.

◆ iter_category_t

template<typename It >
using daw::iter_category_t = typedef typename std::iterator_traits<daw::remove_cvref_t<It> >::iterator_category

Definition at line 42 of file daw_iterator_traits.h.

◆ iter_const_reference_t

Definition at line 38 of file daw_iterator_traits.h.

◆ iter_difference_t

template<typename It >
using daw::iter_difference_t = typedef typename std::iterator_traits<daw::remove_cvref_t<It> >::difference_type

Definition at line 34 of file daw_iterator_traits.h.

◆ iter_pointer_t

template<typename It >
using daw::iter_pointer_t = typedef typename std::iterator_traits<daw::remove_cvref_t<It> >::pointer

Definition at line 30 of file daw_iterator_traits.h.

◆ iter_reference_t

template<typename It >
using daw::iter_reference_t = typedef typename std::iterator_traits<daw::remove_cvref_t<It> >::reference

Definition at line 26 of file daw_iterator_traits.h.

◆ iter_reference_type

Definition at line 295 of file daw_concepts.h.

◆ iter_value_t

template<typename It >
using daw::iter_value_t = typedef typename std::iterator_traits<daw::remove_cvref_t<It> >::value_type

Definition at line 22 of file daw_iterator_traits.h.

◆ iter_value_type

Definition at line 298 of file daw_concepts.h.

◆ iterator_category_t

template<typename T >
using daw::iterator_category_t = typedef typename std::iterator_traits<T>::iterator_category

Definition at line 291 of file daw_concepts.h.

◆ iterator_end_t

template<Range R>
using daw::iterator_end_t = typedef DAW_TYPEOF( std::end( std::declval<R>( ) ) )

Definition at line 176 of file daw_iterator_traits.h.

◆ iterator_t

template<Range R>
using daw::iterator_t = typedef DAW_TYPEOF( std::begin( std::declval<R>( ) ) )

Definition at line 173 of file daw_iterator_traits.h.

◆ make_signed_t

Definition at line 179 of file daw_arith_traits.h.

◆ make_unsigned_t

Definition at line 176 of file daw_arith_traits.h.

◆ md_stdarray_t

template<typename T , std::size_t... Extents>
using daw::md_stdarray_t = typedef typename md_stdarray<T, Extents...>::type

Definition at line 123 of file daw_array.h.

◆ negation

template<typename B >
using daw::negation = typedef std::bool_constant<not bool( B::value )>

Definition at line 30 of file cpp_17.h.

◆ nibble_queue

Definition at line 196 of file daw_bit_queues.h.

◆ non_owning_ptr

Definition at line 365 of file daw_utility.h.

◆ not_null_pointer_const_reference_t

template<typename Pointer >
using daw::not_null_pointer_const_reference_t = typedef std::conditional_t<std::is_pointer_v<Pointer>, Pointer, Pointer const &>

Definition at line 57 of file daw_not_null.h.

◆ not_null_pointer_reference_t

template<typename Pointer >
using daw::not_null_pointer_reference_t = typedef std::conditional_t<std::is_pointer_v<Pointer>, Pointer, Pointer &>

Definition at line 53 of file daw_not_null.h.

◆ not_null_value_const_reference_t

template<typename Pointer >
using daw::not_null_value_const_reference_t = typedef std::conditional_t<std::is_pointer_v<Pointer>, std::remove_pointer_t<Pointer> const &, not_null_value_type_t<Pointer> const &>

Definition at line 47 of file daw_not_null.h.

◆ not_null_value_reference_t

template<typename Pointer >
using daw::not_null_value_reference_t = typedef std::conditional_t<std::is_pointer_v<Pointer>, std::remove_pointer_t<Pointer> const &, not_null_value_type_t<Pointer> &>

Definition at line 41 of file daw_not_null.h.

◆ not_null_value_type_t

Definition at line 38 of file daw_not_null.h.

◆ not_trait

template<typename T >
using daw::not_trait = typedef std::bool_constant<not T::value>

Definition at line 108 of file cpp_17.h.

◆ nothing

Definition at line 14 of file daw_empty.h.

◆ pack_element_t

template<std::size_t Idx, typename Pack >
using daw::pack_element_t = typedef typename pack_element<Idx, Pack>::type

Definition at line 29 of file daw_pack_element.h.

◆ pack_index_of

template<typename T , typename... Ts>
using daw::pack_index_of = typedef std::integral_constant<std::size_t, pack_index_of_v<T, Ts...> >

Definition at line 638 of file daw_utility.h.

◆ pack_size

template<typename Pack >
using daw::pack_size = typedef std::integral_constant<std::size_t, pack_size_v<Pack> >

Definition at line 38 of file daw_pack_element.h.

◆ pack_type_at

template<size_t N, typename... Ts>
using daw::pack_type_at = typedef traits::nth_type<N, Ts...>

Definition at line 624 of file daw_utility.h.

◆ pack_type_t

template<size_t N, typename... Args>
using daw::pack_type_t = typedef typename pack_type<N, Args...>::type

Definition at line 319 of file daw_traits_impl.h.

◆ param_pack_index_of

template<typename Pack , typename T >
using daw::param_pack_index_of = typedef std::integral_constant<std::size_t, param_pack_index_of_v<Pack, T> >

Definition at line 649 of file daw_utility.h.

◆ pointer_to_const_member_function_t

template<typename ResultType , typename ClassType , typename... ArgTypes>
using daw::pointer_to_const_member_function_t = typedef typename utility_details::make_pointer_to_const_member_function_impl< ResultType, ClassType, ArgTypes...>::type

Definition at line 88 of file daw_utility.h.

◆ pointer_to_const_volatile_member_function_t

template<typename ResultType , typename ClassType , typename... ArgTypes>
using daw::pointer_to_const_volatile_member_function_t = typedef typename utility_details:: make_pointer_to_const_volatile_member_function_impl<ResultType, ClassType, ArgTypes...>::type

Definition at line 93 of file daw_utility.h.

◆ pointer_to_member_function_t

template<typename ResultType , typename ClassType , typename... ArgTypes>
using daw::pointer_to_member_function_t = typedef typename utility_details::make_pointer_to_member_function_impl< ResultType, ClassType, ArgTypes...>::type

Definition at line 78 of file daw_utility.h.

◆ pointer_to_volatile_member_function_t

template<typename ResultType , typename ClassType , typename... ArgTypes>
using daw::pointer_to_volatile_member_function_t = typedef typename utility_details::make_pointer_to_volatile_member_function_impl< ResultType, ClassType, ArgTypes...>::type

Definition at line 83 of file daw_utility.h.

◆ range_category_t

Definition at line 196 of file daw_iterator_traits.h.

◆ range_const_reference_t

Definition at line 193 of file daw_iterator_traits.h.

◆ range_reference_t

Definition at line 190 of file daw_iterator_traits.h.

◆ range_value_t

Definition at line 187 of file daw_iterator_traits.h.

◆ remove_array_ref_t

Definition at line 22 of file daw_remove_array_ref.h.

◆ remove_cvref_t

template<typename T >
using daw::remove_cvref_t = typedef std::remove_cv_t<std::remove_reference_t<T> >

Definition at line 17 of file daw_remove_cvref.h.

◆ remove_cvrvref_t

template<typename T >
using daw::remove_cvrvref_t = typedef std::conditional_t<std::is_rvalue_reference_v<T>, remove_cvref_t<T>, T>

Make rvalue references remove_cvref_t<T> and alone otherwise.

Definition at line 21 of file daw_remove_cvref.h.

◆ remove_rvalue_ref_t

template<typename T >
using daw::remove_rvalue_ref_t = typedef daw::conditional_t<std::is_rvalue_reference_v<T>, daw::remove_cvref_t<T>, T>

Definition at line 19 of file daw_tuple_forward.h.

◆ required

template<bool B, typename T = std::nullptr_t>
using daw::required = typedef std::enable_if_t<B, T>

Definition at line 311 of file daw_traits_impl.h.

◆ root_type_t

template<typename T >
using daw::root_type_t = typedef std::remove_cv_t<std::remove_pointer_t<std::decay_t<T> >>

Definition at line 80 of file daw_concepts.h.

◆ rvalue_to_value_t

Definition at line 932 of file daw_traits.h.

◆ safe_string

Definition at line 67 of file daw_safe_string.h.

◆ safe_u16string

Definition at line 73 of file daw_safe_string.h.

◆ safe_u32string

Definition at line 76 of file daw_safe_string.h.

◆ safe_wstring

Definition at line 70 of file daw_safe_string.h.

◆ String

using daw::String = typedef daw::string::string_details::BasicString<char>

Definition at line 512 of file daw_string.h.

◆ switch_t

template<std::size_t Index, typename... Cases>
using daw::switch_t = typedef pack_element_t<Index, pack_list<Cases...> >

Definition at line 853 of file daw_traits.h.

◆ tuple2_element_t

Definition at line 157 of file daw_tuple2.h.

◆ type_n_t

template<size_t N, typename... Args>
using daw::type_n_t = typedef traits::nth_element<N, Args...>

Definition at line 295 of file daw_traits_impl.h.

◆ u16bounded_string

Definition at line 755 of file daw_bounded_string.h.

◆ u32bounded_string

Definition at line 756 of file daw_bounded_string.h.

◆ UInt

template<unsigned Bits>
using daw::UInt = typedef conditional_t< ( Bits == 8 ), UInt8, conditional_t< ( Bits == 16 ), UInt16, conditional_t<( Bits == 32 ), UInt32, conditional_t<( Bits == 64 ), UInt64, InvalidUIntSize> >> >

Definition at line 55 of file daw_uint_types.h.

◆ uintN_t

Definition at line 216 of file daw_arith_traits.h.

◆ void_t

template<typename... >
using daw::void_t = typedef void

Definition at line 945 of file daw_traits.h.

◆ wbounded_string

Definition at line 754 of file daw_bounded_string.h.

◆ WString

using daw::WString = typedef daw::string::string_details::BasicString<wchar_t>

Definition at line 513 of file daw_string.h.

Enumeration Type Documentation

◆ endian

Enumerator
little 
big 
native 

Definition at line 21 of file daw_endian.h.

◆ keep_n_order

Enumerator
ascending 
descending 

Definition at line 20 of file daw_keep_n.h.

◆ UInt16

enum class daw::UInt16 : std::uint16_t
strong

Definition at line 27 of file daw_uint_types.h.

◆ UInt32

enum class daw::UInt32 : std::uint32_t
strong

Definition at line 26 of file daw_uint_types.h.

◆ UInt64

enum class daw::UInt64 : std::uint64_t
strong

Definition at line 25 of file daw_uint_types.h.

◆ UInt8

enum class daw::UInt8 : std::uint8_t
strong

Definition at line 28 of file daw_uint_types.h.

◆ wait_status

Enumerator
found 
timeout 

Definition at line 20 of file daw_atomic_wait.h.

Function Documentation

◆ advance()

template<typename Iterator , typename Distance >
constexpr void daw::advance ( Iterator &  it,
Distance  n 
)
constexpr

Advance iterator n steps.

Template Parameters
IteratorType of iterator to advance
DistanceA type convertible to an integral type
Parameters
ititerator to advance
nhow far to move iterator

Definition at line 111 of file cpp_17_iterator.h.

◆ advance_many() [1/2]

template<typename Distance , typename Iterator >
constexpr void daw::advance_many ( Distance  d,
Iterator &  it 
)
constexpr

Definition at line 73 of file daw_algorithm.h.

◆ advance_many() [2/2]

template<typename Distance , typename Iterator , typename Iterator2 , typename... Iterators>
constexpr void daw::advance_many ( Distance  d,
Iterator &  it,
Iterator2 it2,
Iterators &...  its 
)
constexpr

Definition at line 79 of file daw_algorithm.h.

◆ any_if()

template<typename... Predicates>
requires ( (Fn<Predicates, bool()> or std::convertible_to<Predicates, bool>) and ...)
constexpr bool daw::any_if ( Predicates &&...  predicates)
constexpr

Definition at line 17 of file daw_any_if.h.

◆ any_of_f()

template<typename... Ts>
constexpr auto daw::any_of_f ( Ts &&...  needles)
constexprnoexcept

Definition at line 41 of file daw_view_tags.h.

◆ append()

template<typename Container , typename... Args>
constexpr auto daw::append ( Container container,
Args &&...  args 
)
constexpr

Definition at line 373 of file daw_utility.h.

◆ apply() [1/10]

template<bool use_invoke = true, typename F , typename Tuple >
constexpr decltype(auto) daw::apply ( F &&  f,
Tuple &&  t 
)
inlineconstexpr

Definition at line 147 of file daw_apply.h.

◆ apply() [2/10]

template<typename F , typename... Ts>
constexpr decltype(auto) daw::apply ( F &&  f,
tuple< Ts... > &&  t 
)
inlineconstexpr

Definition at line 294 of file daw_tuple.h.

◆ apply() [3/10]

template<typename F , typename... Ts>
constexpr decltype(auto) daw::apply ( F &&  f,
tuple< Ts... > &  t 
)
inlineconstexpr

Definition at line 280 of file daw_tuple.h.

◆ apply() [4/10]

template<typename F , typename... Ts>
constexpr decltype(auto) daw::apply ( F &&  f,
tuple< Ts... > const &&  t 
)
inlineconstexpr

Definition at line 302 of file daw_tuple.h.

◆ apply() [5/10]

template<typename F , typename... Ts>
constexpr decltype(auto) daw::apply ( F &&  f,
tuple< Ts... > const t 
)
inlineconstexpr

Definition at line 287 of file daw_tuple.h.

◆ apply() [6/10]

template<typename Func , typename... Ts>
constexpr decltype(auto) daw::apply ( Func &&  func,
fwd_pack< Ts... > &&  p 
)
constexprnoexcept

Definition at line 119 of file daw_fwd_pack_apply.h.

◆ apply() [7/10]

template<typename Func , typename... Ts>
constexpr decltype(auto) daw::apply ( tuple2< Ts... > &&  tp,
Func &&  fn 
)
inlineconstexpr

Definition at line 259 of file daw_tuple2.h.

◆ apply() [8/10]

template<typename Func , typename... Ts>
constexpr decltype(auto) daw::apply ( tuple2< Ts... > &  tp,
Func &&  fn 
)
inlineconstexpr

Definition at line 244 of file daw_tuple2.h.

◆ apply() [9/10]

template<typename Func , typename... Ts>
constexpr decltype(auto) daw::apply ( tuple2< Ts... > const &&  tp,
Func &&  fn 
)
inlineconstexpr

Definition at line 251 of file daw_tuple2.h.

◆ apply() [10/10]

template<typename Func , typename... Ts>
constexpr decltype(auto) daw::apply ( tuple2< Ts... > const tp,
Func &&  fn 
)
inlineconstexpr

Definition at line 236 of file daw_tuple2.h.

◆ apply_string() [1/3]

template<typename Arg , typename Callable >
constexpr decltype(auto) daw::apply_string ( Callable &&  callable,
daw::string_view  str 
)
constexpr

Apply the reified string as the types specified as Arg to the Callable.

Template Parameters
ArgType of expected data to find in string
CallableCallable function type that will accept the arg in string
Parameters
callableFunction to apply argument to
strString data with string encoded argument
Returns
result of callable

Definition at line 474 of file daw_parse_to.h.

◆ apply_string() [2/3]

template<typename... Args, typename Callable >
constexpr decltype(auto) daw::apply_string ( Callable &&  callable,
daw::string_view  str,
daw::string_view  delemiter 
)
constexpr

Apply the reified string as the types specified as Args... to the Callable.

Template Parameters
ArgsTypes of expected data to find in string
CallableCallable function type that will accept the args in string
Parameters
callableFunction to apply arguments to
strString data with string encoded arguments
delemitersplit what string arguments on
Returns
result of callable

Definition at line 451 of file daw_parse_to.h.

◆ apply_string() [3/3]

template<typename... Args, typename Callable , typename Splitter , std::enable_if_t< std::is_invocable_v< Splitter, daw::string_view >, std::nullptr_t > = nullptr>
constexpr decltype(auto) daw::apply_string ( Callable &&  callable,
daw::string_view  str,
Splitter &&  splitter 
)
constexpr

Apply the reified string as the types specified as Args... to the Callable.

Template Parameters
ArgsTypes of expected data to find in string
CallableCallable function type that will accept the args in string
SplitterA predicate that will return true on the string parts to split on
Parameters
callableFunction to apply arguments to
strString data with string encoded arguments
splitterFunction to split string into arguments
Returns
result of callable

Definition at line 428 of file daw_parse_to.h.

◆ apply_string2() [1/2]

template<typename Callable >
constexpr decltype(auto) daw::apply_string2 ( Callable &&  callable,
daw::string_view  str,
daw::string_view  delemiter 
)
constexpr

Apply the reified string as the types deducted from the Callable to the Callable. This may have unexpected results if strings are ot controlled.

Template Parameters
CallableCan be called with operator( )
Parameters
callablea function that takes deducted arguments
strString containing encoded values
delemitersplit what string arguments on
Returns
The result of callable

Definition at line 407 of file daw_parse_to.h.

◆ apply_string2() [2/2]

template<typename Callable , typename Splitter , std::enable_if_t< std::is_invocable_v< Splitter, daw::string_view >, std::nullptr_t > = nullptr>
constexpr decltype(auto) daw::apply_string2 ( Callable &&  callable,
daw::string_view  str,
Splitter &&  splitter 
)
constexpr

Apply the reified string as the types deducted from the Callable to the Callable. This may have unexpected results if strings are ot controlled.

Template Parameters
CallableCan be called with operator( )
SplitterCallable splitter that returns the next position of a value
Parameters
callablea function that takes deducted arguments
strString containing encoded values
splitterFunction to split string into arguments
Returns
The result of callable

Definition at line 389 of file daw_parse_to.h.

◆ are_set()

template<typename Integer , typename MaskBit , typename... MaskBits>
constexpr bool daw::are_set ( Integer  value,
MaskBit  mask_bit,
MaskBits...  mask_bits 
)
constexprnoexcept

Definition at line 61 of file daw_bit.h.

◆ array_cmp()

template<typename T , typename Compare = std::equal_to<>, typename U = std::enable_if_t<std::is_array_v<remove_array_ref_t<T>>, remove_array_ref_t<T>>>
constexpr auto daw::array_cmp ( T &&  lhs,
T &&  rhs,
Compare const cmp = Compare{ } 
)
constexpr

Definition at line 35 of file daw_array_compare.h.

◆ as_char_array()

template<typename From >
auto daw::as_char_array ( From &&  from)
noexcept

Definition at line 780 of file daw_utility.h.

◆ as_const()

template<typename T >
constexpr std::add_const_t< T > & daw::as_const ( T const t)
constexprnoexcept

Definition at line 111 of file cpp_17.h.

◆ AsciiLower() [1/2]

constexpr char daw::AsciiLower ( char  chr)
constexprnoexcept

Definition at line 306 of file daw_utility.h.

◆ AsciiLower() [2/2]

template<typename CharType , typename Traits , typename Allocator >
constexpr auto daw::AsciiLower ( std::basic_string< CharType, Traits, Allocator >  str)
constexprnoexcept

Definition at line 326 of file daw_utility.h.

◆ AsciiUpper() [1/2]

constexpr char daw::AsciiUpper ( char  chr)
constexprnoexcept

Definition at line 298 of file daw_utility.h.

◆ AsciiUpper() [2/2]

template<typename CharType , typename Traits , typename Allocator >
constexpr auto daw::AsciiUpper ( std::basic_string< CharType, Traits, Allocator >  str)
constexprnoexcept

Definition at line 316 of file daw_utility.h.

◆ atomic_wait_for()

template<typename T , typename Rep , typename Period >
wait_status daw::atomic_wait_for ( std::atomic< T > const object,
T const old,
std::chrono::duration< Rep, Period > const rel_time,
std::memory_order  order = std::memory_order_acquire 
)

Waits for the atomic object to change from the old value or until the timeout expires.

This function blocks the calling thread, periodically polling the atomic object, and returns as soon as the atomic value differs from the specified old value or the relative timeout period elapses.

Template Parameters
TThe type of the atomic object.
RepThe representation type of the relative time duration.
PeriodThe tick period type of the relative time duration.
Parameters
objectPointer to the atomic object to wait on.
oldThe value that the atomic object is expected to differ from.
rel_timeThe maximum duration to wait before timing out.
orderThe memory order to use for atomic load operations. Defaults to std::memory_order_acquire.
Returns
A wait_status indicating whether the atomic value changed or the timeout expired.

Definition at line 92 of file daw_atomic_wait.h.

◆ atomic_wait_if()

template<typename T >
void daw::atomic_wait_if ( std::atomic< T > const object,
Fn< bool(T)> auto &&  predicate,
std::memory_order  order = std::memory_order_acquire 
)

Waits until the atomic object satisfies the given predicate.

This function blocks the calling thread until the value of the atomic object pointed to by object satisfies the provided predicate.

Template Parameters
TThe type of the atomic object.
FnA templated function type that takes a value of type T and returns bool.
Parameters
objectPointer to the atomic object to wait on.
predicateA callable object (such as a lambda or function object) that takes a value of type T and returns a boolean indicating whether the condition is met.
orderThe memory order to use. Defaults to std::memory_order_acquire.

Definition at line 171 of file daw_atomic_wait.h.

◆ atomic_wait_if_for()

template<typename T , typename Rep , typename Period >
wait_status daw::atomic_wait_if_for ( std::atomic< T > const object,
Fn< bool(T)> auto &&  predicate,
std::chrono::duration< Rep, Period > const rel_time,
std::memory_order  order = std::memory_order_acquire 
)

Waits for an atomic object to satisfy a predicate within a specified time duration.

This function blocks the calling thread until the predicate applied to the atomic object evaluates to true or the specified timeout period elapses.

Template Parameters
TThe type of the atomic object.
FnA callable type that returns a boolean value when applied to an object of type T.
RepA type representing the number of ticks of the time duration.
PeriodA std::ratio type representing the tick period of the time duration.
Parameters
objectPointer to the atomic object to wait on.
predicatePredicate function to apply to the atomic object's value.
rel_timeThe relative time duration to wait for the predicate to become true.
orderThe memory order to use for atomic operations. Defaults to std::memory_order_acquire.
Returns
Returns wait_status::found if the predicate evaluates to true before the timeout, and wait_status::timeout otherwise.

Definition at line 210 of file daw_atomic_wait.h.

◆ atomic_wait_if_until()

wait_status daw::atomic_wait_if_until ( std::atomic< T > const object,
Fn< bool(T)> auto &&  predicate,
std::chrono::time_point< Clock, Duration > const timeout_time,
std::memory_order  order = std::memory_order_acquire 
)

Waits until the atomic object satisfies the given predicate or the absolute timeout time is reached.

This function blocks the calling thread until the atomic value pointed to by object satisfies the predicate function or the specified timeout time timeout_time is reached.

Template Parameters
TThe type of the atomic object.
ClockThe clock used for the timeout.
DurationThe duration type used by the clock.
FnA callable type that takes a value of type T and returns a bool.
Parameters
objectPointer to the atomic object to wait on.
predicateA callable that takes the atomic object's value and returns whether it satisfies the condition.
timeout_timeThe absolute time point by which the wait operation should be aborted if the predicate is not satisfied.
orderThe memory order to use. Defaults to std::memory_order_acquire.
Returns
A wait_status enum indicating whether the predicate was satisfied or a timeout occurred.

Definition at line 267 of file daw_atomic_wait.h.

◆ atomic_wait_until()

wait_status daw::atomic_wait_until ( std::atomic< T > const object,
T const old,
std::chrono::time_point< Clock, Duration > const timeout_time,
std::memory_order  order = std::memory_order_acquire 
)

Waits until the atomic object changes from the specified value or the timeout time is reached.

This function blocks the calling thread until the atomic value pointed to by object is not equal to old or until the specified timeout_time is reached.

Template Parameters
TThe type of the atomic object.
ClockThe clock type used to measure the timeout.
DurationThe duration type used to represent the timeout.
Parameters
objectPointer to the atomic object to wait on.
oldThe value that the atomic object is expected to change from
timeout_timeThe time point at which the wait is aborted if the value has not been reached.
orderThe memory order to use. Defaults to std::memory_order_acquire.
Returns
A wait_status indicating whether the wait was successful or if it timed out.

Definition at line 144 of file daw_atomic_wait.h.

◆ atomic_wait_value_equal()

template<typename T >
void daw::atomic_wait_value_equal ( std::atomic< T > const object,
T const desired_value,
std::memory_order  order = std::memory_order_acquire 
)

Waits until the atomic object reaches the desired value.

This function blocks the calling thread until the atomic value pointed to by object equals desired_value.

Template Parameters
TThe type of the atomic object.
Parameters
objectPointer to the atomic object to wait on.
desired_valueThe value that the atomic object is expected to reach.
orderThe memory order to use. Defaults to std::memory_order_acquire.

Definition at line 289 of file daw_atomic_wait.h.

◆ atomic_wait_value_equal_for()

template<typename T , typename Rep , typename Period >
wait_status daw::atomic_wait_value_equal_for ( std::atomic< T > const object,
T const desired_value,
std::chrono::duration< Rep, Period > const rel_time,
std::memory_order  order = std::memory_order_acquire 
)

Waits until the atomic object reaches the desired value or the relative time duration has elapsed.

This function blocks the calling thread until the atomic value pointed to by object equals desired_value or the specified relative time duration rel_time has elapsed.

Template Parameters
TThe type of the atomic object.
RepThe type representing the number of ticks.
PeriodThe type representing the tick period.
Parameters
objectPointer to the atomic object to wait on.
desired_valueThe value that the atomic object is expected to reach.
rel_timeThe maximum duration to wait for the atomic object to reach the desired value.
orderThe memory order to use. Defaults to std::memory_order_acquire.
Returns
A wait_status enum indicating whether the desired value was found or a timeout occurred.

Definition at line 323 of file daw_atomic_wait.h.

◆ atomic_wait_value_equal_until()

wait_status daw::atomic_wait_value_equal_until ( std::atomic< T > const object,
T const desired_value,
std::chrono::time_point< Clock, Duration > const timeout_time,
std::memory_order  order = std::memory_order_acquire 
)

Waits until the specified object reaches the desired value or the timeout is reached.

This function blocks the calling thread until the atomic value pointed to by object equals desired_value or the specified timeout time timeout_time is reached.

Template Parameters
TThe type of the atomic object.
ClockThe clock used for the timeout.
DurationThe duration type used by the clock.
Parameters
objectPointer to the atomic object to wait on.
desired_valueThe value that the atomic object is expected to reach.
timeout_timeThe absolute time point by which the wait operation should be aborted if the desired value is not reached.
orderThe memory order to use. Defaults to std::memory_order_acquire.
Returns
A wait_status enum indicating whether the desired value was found or a timeout occurred.

Definition at line 358 of file daw_atomic_wait.h.

◆ back_inserter()

◆ basic_bounded_string() [1/2]

template<typename... Chars, std::enable_if_t< daw::traits::all_same_v< char, Chars... >, std::nullptr_t > = nullptr>
daw::basic_bounded_string ( Chars...  ) -> basic_bounded_string< char, sizeof...(Chars)>

◆ basic_bounded_string() [2/2]

template<typename CharT , size_t N>
daw::basic_bounded_string ( CharT   const(&)[N]) -> basic_bounded_string< CharT, N >

◆ begin_at() [1/2]

template<typename Container >
constexpr auto daw::begin_at ( Container container,
size_t  n 
) -> decltype( std::begin( container ) )
constexprnoexcept

Take iterator return from begin of a container and return the result of running next with n steps.

Template Parameters
ContainerContainer type iterator will come from
Parameters
containercontainer to get iterator from
nhow many steps to move forward from begin
Returns
an iterator referencing a value in container n steps from begin

Definition at line 218 of file daw_algorithm.h.

◆ begin_at() [2/2]

template<typename Container >
constexpr auto daw::begin_at ( Container const container,
size_t  n 
) -> decltype( std::cbegin( container ) )
constexprnoexcept

Take iterator return from begin of a container and return the result of running next with n steps.

Template Parameters
ContainerContainer type iterator will come from
Parameters
containercontainer to get iterator from
nhow many steps to move forward from begin
Returns
an iterator referencing a value in container n steps from begin

Definition at line 236 of file daw_algorithm.h.

◆ bench_n_test()

template<size_t Runs, char delem = '\n', typename Test , typename... Args>
DAW_ATTRIB_NOINLINE auto daw::bench_n_test ( std::string const title,
Test &&  test_callable,
Args const &...  args 
)
noexcept
Template Parameters
RunsNumber of runs to do
delemdelemiter in output
TestCallable type to benchmark
Argstypes passed to callable
Parameters
titleTitle of benchmark
test_callablecallable to benchmark
argsarg values to pass to callable
Returns
last value from callable

Definition at line 206 of file daw_benchmark.h.

◆ bench_n_test_json()

template<size_t Runs, typename Function , typename... Args>
DAW_ATTRIB_NOINLINE std::vector< std::chrono::nanoseconds > daw::bench_n_test_json ( Function &&  func,
Args &&...  args 
)
noexcept
Template Parameters
RunsNumber of runs
FunctionCallable type to be timed
Argstypes to pass to callable
Parameters
funcCallable value to bench
argsargs values to pass to func
Returns
last result timing counts of runs

Definition at line 480 of file daw_benchmark.h.

◆ bench_n_test_json_val()

template<size_t Runs, typename Validator , typename Function , typename... Args>
DAW_ATTRIB_NOINLINE std::vector< std::chrono::nanoseconds > daw::bench_n_test_json_val ( Validator &&  validator,
Function &&  func,
Args &&...  args 
)
noexcept
Template Parameters
RunsNumber of runs
ValidatorCallable to validate results
FunctionCallable type to be timed
Argstypes to pass to callable
Parameters
validatorvalidatio object that takes func's result as arg
funcCallable value to bench
argsargs values to pass to func
Returns
last result timing counts of runs

Definition at line 532 of file daw_benchmark.h.

◆ bench_n_test_mbs()

template<size_t Runs, char delem = '\n', typename Test , typename... Args>
DAW_ATTRIB_NOINLINE auto daw::bench_n_test_mbs ( std::string const title,
size_t  bytes,
Test &&  test_callable,
Args const &...  args 
)
noexcept

Definition at line 370 of file daw_benchmark.h.

◆ bench_n_test_mbs2()

template<size_t Runs, char delem = '\n', typename Validator , typename Function , typename... Args>
DAW_ATTRIB_NOINLINE std::array< double, Runs > daw::bench_n_test_mbs2 ( std::string const ,
size_t  ,
Validator &&  validator,
Function &&  func,
Args const &...  args 
)
noexcept
Template Parameters
RunsNumber of runs
delemDelemiter in output
ValidatorCallable to validate results
FunctionCallable type to be timed
Argstypes to pass to callable
Parameters
titleTitle for output
bytesSize of data in bytes
validatorvalidatio object that takes func's result as arg
funcCallable value to bench
argsargs values to pass to func
Returns
last result timing counts of runs

Definition at line 315 of file daw_benchmark.h.

◆ bench_test()

template<typename Test , typename... Args>
DAW_ATTRIB_NOINLINE auto daw::bench_test ( std::string const title,
Test &&  test_callable,
Args &&...  args 
)

Definition at line 135 of file daw_benchmark.h.

◆ bench_test2()

template<typename Test , typename... Args>
DAW_ATTRIB_NOINLINE auto daw::bench_test2 ( std::string const title,
Test &&  test_callable,
size_t  item_count,
Args &&...  args 
)

Definition at line 162 of file daw_benchmark.h.

◆ benchmark()

template<typename F >
DAW_ATTRIB_NOINLINE double daw::benchmark ( F &&  func)

Definition at line 35 of file daw_benchmark.h.

◆ bfs_walk() [1/2]

template<typename ChildOrder = UnorderedWalk, typename T , typename Function >
void daw::bfs_walk ( daw::graph_t< T > &  graph,
daw::node_id_t  start_node_id,
Function &&  func,
ChildOrder  ord = ChildOrder{ } 
)

Definition at line 539 of file daw_graph_algorithm.h.

◆ bfs_walk() [2/2]

template<typename ChildOrder = UnorderedWalk, typename T , typename Function >
void daw::bfs_walk ( daw::graph_t< T > const graph,
daw::node_id_t  start_node_id,
Function &&  func,
ChildOrder  ord = ChildOrder{ } 
)

Definition at line 532 of file daw_graph_algorithm.h.

◆ bidirectional_counting_iterator()

◆ bind_args_at()

template<std::size_t N, typename Invokable , typename... Args>
constexpr auto daw::bind_args_at ( Invokable &&  func,
Args &&...  args 
)
constexpr

Definition at line 133 of file daw_bind_args_at.h.

◆ bind_front()

template<typename Function , typename... Params>
daw::bind_front ( Function  ,
Params...   
) -> bind_front< Function, Params... >

◆ bit_cast()

template<typename To , typename From >
To daw::bit_cast ( From &&  from)
noexcept

Definition at line 32 of file daw_bit_cast.h.

◆ bit_cast_copy()

template<typename T = deduced_type, typename Iterator , typename OutputIterator >
void daw::bit_cast_copy ( Iterator  first,
Iterator  last,
OutputIterator  first_out 
)

Definition at line 51 of file daw_bit_cast_util.h.

◆ bit_cast_for_each()

template<typename T , typename Iterator , typename Function >
void daw::bit_cast_for_each ( Iterator  first,
Iterator  last,
Function &&  func 
)
noexcept

Definition at line 21 of file daw_bit_cast_util.h.

◆ bit_cast_transform()

template<typename T , typename U = deduced_type, typename Iterator , typename OutputIterator , typename Function >
void daw::bit_cast_transform ( Iterator  first,
Iterator  last,
OutputIterator  first_out,
Function &&  func 
)

Definition at line 33 of file daw_bit_cast_util.h.

◆ bitcount() [1/2]

template<typename Value >
constexpr std::size_t daw::bitcount ( Value  value)
constexprnoexcept

Definition at line 409 of file daw_utility.h.

◆ bitcount() [2/2]

template<typename Value , typename... T>
constexpr std::size_t daw::bitcount ( Value  value,
T...  values 
)
constexprnoexcept

Definition at line 419 of file daw_utility.h.

◆ block_append_from()

template<typename T , typename Allocator = std::allocator<T>, input_iterator InputIterator>
constexpr void daw::block_append_from ( vector< T, Allocator > &  v,
InputIterator  first,
InputIterator  last,
std::size_t  block_size = 512 
)
constexpr

Definition at line 1312 of file vector.h.

◆ block_create_from()

template<typename T , typename Allocator = std::allocator<T>, input_iterator InputIterator>
constexpr vector< T, Allocator > daw::block_create_from ( InputIterator  first,
InputIterator  last,
std::size_t  block_size = 512 
)
constexpr

Definition at line 1336 of file vector.h.

◆ bounded_hash_map()

template<typename Key , typename Value , typename Hash = std::hash<Key>, size_t N>
daw::bounded_hash_map ( std::pair< Key, Value > const (&&)  items[N]) -> bounded_hash_map< Key, Value, N, Hash >

◆ bounded_hash_map_item_t()

◆ breakpoint()

constexpr void daw::breakpoint ( )
constexprnoexcept

Definition at line 439 of file daw_utility.h.

◆ can_extract() [1/2]

template<typename T , typename... Args>
constexpr bool daw::can_extract ( std::variant< Args... > &&  var)
constexprnoexcept

Definition at line 86 of file daw_variant_cast.h.

◆ can_extract() [2/2]

template<typename T , typename... Args>
constexpr bool daw::can_extract ( std::variant< Args... > const var)
constexprnoexcept

Definition at line 81 of file daw_variant_cast.h.

◆ can_fit()

constexpr bool daw::can_fit ( IntegerSource const  value)
constexprnoexcept

Definition at line 425 of file daw_utility.h.

◆ cast()

template<typename T , bool AllowDownSignCast = false, typename U >
constexpr decltype(auto) daw::cast ( U &&  v)
constexpr

Definition at line 919 of file daw_utility.h.

◆ checked_from_code()

template<typename... ExpectedExceptions, typename Function , typename... Args>
auto daw::checked_from_code ( Function  func,
Args &&...  args 
)

Definition at line 390 of file daw_checked_expected.h.

◆ chunk_iterator()

template<typename Iterator >
daw::chunk_iterator ( Iterator  ,
std::size_t   
) -> chunk_iterator< Iterator >

◆ cibegin() [1/3]

template<typename T >
constexpr auto daw::cibegin ( T &&  container)
constexprnoexcept

Definition at line 217 of file daw_indexed_iterator.h.

◆ cibegin() [2/3]

template<typename T , size_t N>
constexpr auto daw::cibegin ( T const (&)  container[N])
constexprnoexcept

Definition at line 261 of file daw_indexed_iterator.h.

◆ cibegin() [3/3]

template<typename T , size_t N>
constexpr auto daw::cibegin ( T(&)  container[N])
constexprnoexcept

Definition at line 256 of file daw_indexed_iterator.h.

◆ ciend() [1/3]

template<typename T >
constexpr auto daw::ciend ( T &&  container)
constexprnoexcept

Definition at line 236 of file daw_indexed_iterator.h.

◆ ciend() [2/3]

template<typename T , size_t N>
constexpr auto daw::ciend ( T const (&)  container[N])
constexprnoexcept

Definition at line 281 of file daw_indexed_iterator.h.

◆ ciend() [3/3]

template<typename T , size_t N>
constexpr auto daw::ciend ( T(&)  container[N])
constexprnoexcept

Definition at line 276 of file daw_indexed_iterator.h.

◆ cmp_equal()

template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool daw::cmp_equal ( t,
U  u 
)
constexprnoexcept

Definition at line 25 of file daw_int_cmp.h.

◆ cmp_greater()

template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool daw::cmp_greater ( t,
U  u 
)
constexprnoexcept

Definition at line 70 of file daw_int_cmp.h.

◆ cmp_greater_equal()

template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool daw::cmp_greater_equal ( t,
U  u 
)
constexprnoexcept

Definition at line 84 of file daw_int_cmp.h.

◆ cmp_less()

template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool daw::cmp_less ( t,
U  u 
)
constexprnoexcept

Definition at line 55 of file daw_int_cmp.h.

◆ cmp_less_equal()

template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool daw::cmp_less_equal ( t,
U  u 
)
constexprnoexcept

Definition at line 77 of file daw_int_cmp.h.

◆ cmp_not_equal()

template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool daw::cmp_not_equal ( t,
U  u 
)
constexprnoexcept

Definition at line 40 of file daw_int_cmp.h.

◆ construct_at() [1/2]

template<typename T , typename Storage , typename... Args>
T * daw::construct_at ( Storage p,
Args &&...  args 
)
inline

Definition at line 21 of file daw_construct_at.h.

◆ construct_at() [2/2]

template<typename T , typename... Args>
constexpr T * daw::construct_at ( T *  p,
Args &&...  args 
)
constexpr

Definition at line 203 of file daw_vector.h.

◆ construct_from() [1/5]

constexpr decltype(auto) daw::construct_from ( daw::string_view  str)
constexpr

Contructs an object from the arguments specified in the string using a default delemiter of " ".

Template Parameters
DestinationThe type of object to construct
ExpectedArgThe type of value to parse out of the string
Parameters
strString containing encoded values
Returns
A constructed Destination

Definition at line 361 of file daw_parse_to.h.

◆ construct_from() [2/5]

template<typename Destination , typename... ExpectedArgs>
constexpr decltype(auto) daw::construct_from ( daw::string_view  str,
daw::string_view  delemiter 
)
constexpr

Contructs an object from the arguments specified in the string.

Template Parameters
DestinationThe type of object to construct
ExpectedArgsThe types of values to parse out of the string
Parameters
strString containing encoded values
delemiterthat str is split on
Returns
A constructed Destination

Definition at line 347 of file daw_parse_to.h.

◆ construct_from() [3/5]

template<typename Destination , typename... ExpectedArgs, typename Splitter , std::enable_if_t< std::is_invocable_v< Splitter, daw::string_view >, std::nullptr_t > = nullptr>
constexpr decltype(auto) daw::construct_from ( daw::string_view  str,
Splitter &&  splitter 
)
constexpr

Contructs an object from the arguments specified in the string.

Template Parameters
DestinationThe type of object to construct
ExpectedArgsThe types of values to parse out of the string
SplitterCallable splitter that returns the next position of a value
Parameters
strString containing encoded values
splittersplit what string arguments on
Returns
A constructed Destination

Definition at line 332 of file daw_parse_to.h.

◆ construct_from() [4/5]

template<typename Destination , typename... Args>
constexpr decltype(auto) daw::construct_from ( std::tuple< Args... > &&  args)
constexprnoexcept

Definition at line 680 of file daw_utility.h.

◆ construct_from() [5/5]

template<typename Destination , typename... Args>
constexpr decltype(auto) daw::construct_from ( std::tuple< Args... > const args)
constexprnoexcept

Definition at line 688 of file daw_utility.h.

◆ contains()

constexpr bool daw::contains ( Container const container,
Item const item 
)
constexprnoexcept

Definition at line 378 of file daw_utility.h.

◆ contiguous_view() [1/4]

template<ContiguousContainer Container>
daw::contiguous_view ( Container &&  c) -> contiguous_view< std::remove_reference_t< decltype(*std::data(c))> >

◆ contiguous_view() [2/4]

template<typename T >
daw::contiguous_view ( T *  ,
std::size_t   
) -> contiguous_view< T >

◆ contiguous_view() [3/4]

template<typename T >
daw::contiguous_view ( T *  ,
T *   
) -> contiguous_view< T >

◆ contiguous_view() [4/4]

template<typename T , std::size_t N>
daw::contiguous_view ( T(&)  [N]) -> contiguous_view< T >

◆ contract_failure()

DAW_ATTRIB_NOINLINE void daw::contract_failure ( )
inline

Definition at line 38 of file daw_contract.h.

◆ copy()

template<typename T >
constexpr T daw::copy ( T &&  value)
constexprnoexcept

Definition at line 264 of file daw_utility.h.

◆ copy_n()

template<typename Iterator , typename OutputIterator >
constexpr OutputIterator daw::copy_n ( Iterator  first,
std::size_t  sz,
OutputIterator  out_it 
)
constexprnoexcept

Definition at line 218 of file daw_vector.h.

◆ copy_ptr_value()

template<typename T >
auto daw::copy_ptr_value ( T const *const  original)

Definition at line 359 of file daw_utility.h.

◆ copy_vector()

template<template< class, class > class Vector, typename T , typename A >
constexpr Vector< T, A > daw::copy_vector ( Vector< T, A > const container,
std::size_t  num_items 
)
constexpr

Definition at line 270 of file daw_utility.h.

◆ create_hash_table()

template<typename Key , typename Value >
auto daw::create_hash_table ( std::initializer_list< std::pair< Key, Value > > const values)

Definition at line 666 of file daw_hash_table.h.

◆ cswap() [1/2]

template<typename T , size_t N>
constexpr void daw::cswap ( std::array< T, N > &  lhs,
std::array< T, N > &  rhs 
)
constexprnoexcept

Definition at line 91 of file daw_swap.h.

◆ cswap() [2/2]

template<typename T >
constexpr void daw::cswap ( T &&  lhs,
T &&  rhs 
)
constexprnoexcept

Definition at line 44 of file daw_swap.h.

◆ cxpr_copy()

constexpr OutputIterator daw::cxpr_copy ( Iterator1  first_in,
Iterator2 const  last_in,
OutputIterator  first_out 
)
constexpr

Definition at line 445 of file daw_utility.h.

◆ cxpr_move()

constexpr OutputIterator daw::cxpr_move ( Iterator1  first_in,
Iterator2 const  last_in,
OutputIterator  first_out 
)
constexpr

Definition at line 457 of file daw_utility.h.

◆ data()

template<typename Container >
constexpr auto daw::data ( Container &&  c)
inlineconstexpr

Definition at line 35 of file daw_data_end.h.

◆ data_end()

template<typename Container >
constexpr auto daw::data_end ( Container &&  c)
inlineconstexpr

Definition at line 44 of file daw_data_end.h.

◆ DAW_MAKE_REQ_TRAIT()

daw::DAW_MAKE_REQ_TRAIT ( can_be_bounded_string  ,
daw::bounded_string{ std::declval< T >() }   
)

◆ decay_copy()

template<class T >
constexpr auto daw::decay_copy ( T &&  v) -> std::enable_if_t<std::is_convertible_v<T, std::decay_t<T>>, std::decay_t<T>>
constexprnoexcept

Definition at line 203 of file cpp_17.h.

◆ default_contract_failure()

void daw::default_contract_failure ( )
inline

Definition at line 31 of file daw_contract.h.

◆ deleted()

template<typename... >
void daw::deleted ( )
delete

◆ dfs_walk() [1/2]

template<typename T , typename Function , typename ChildOrder = UnorderedWalk>
void daw::dfs_walk ( daw::graph_t< T > &  graph,
daw::node_id_t  start_node_id,
Function &&  func,
ChildOrder  ord = ChildOrder{ } 
)

Definition at line 553 of file daw_graph_algorithm.h.

◆ dfs_walk() [2/2]

template<typename T , typename Function , typename ChildOrder = UnorderedWalk>
void daw::dfs_walk ( daw::graph_t< T > const graph,
daw::node_id_t  start_node_id,
Function &&  func,
ChildOrder  ord = ChildOrder{ } 
)

Definition at line 546 of file daw_graph_algorithm.h.

◆ distance()

template<typename Iterator >
constexpr ptrdiff_t daw::distance ( Iterator  first,
Iterator  second 
)
constexprnoexcept

Calculate distance between iterators.

Template Parameters
Iteratortype of Iterator to compare
Parameters
firstfirst iterator, must be <= second if Iterators are not RandomAccess
secondsecond iterator, must be >= first if Iterators are not RandomAccess
Returns
a ptrdiff_t of how many steps apart iterators are. If Iterators are RandomAccess it may be <0, otherwise always greater

Definition at line 96 of file cpp_17_iterator.h.

◆ do_not_optimize() [1/2]

template<class T >
DAW_ATTRIB_INLINE void daw::do_not_optimize ( T const value)

Definition at line 46 of file daw_do_not_optimize.h.

◆ do_not_optimize() [2/2]

template<typename... Values, std::enable_if_t<(sizeof...(Values) !=1), std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE void daw::do_not_optimize ( Values &&...  values)

Definition at line 57 of file daw_do_not_optimize.h.

◆ dump()

template<typename... Args>
void daw::dump ( Args &&...  args)

Definition at line 78 of file daw_print.h.

◆ empty_range()

constexpr bool daw::empty_range ( Range auto &&  r)
constexpr

Definition at line 198 of file daw_iterator_traits.h.

◆ end_inserter()

template<typename Container >
constexpr auto daw::end_inserter ( Container c)
constexpr

Definition at line 60 of file daw_end_inserter.h.

◆ end_inserter_iterator()

◆ equal_to()

template<typename T >
constexpr utility_details::EqualToImpl< T > daw::equal_to ( value)
inlineconstexpr

Definition at line 114 of file daw_utility.h.

◆ erase()

template<typename T , typename Allocator >
constexpr vector< T, Allocator >::size_type daw::erase ( vector< T, Allocator > &  c,
auto const v 
)
constexpr

Definition at line 1296 of file vector.h.

◆ erase_if()

template<typename T , typename Allocator >
constexpr vector< T, Allocator >::size_type daw::erase_if ( vector< T, Allocator > &  c,
auto  pred 
)
constexpr

Definition at line 1304 of file vector.h.

◆ exchange()

template<typename T , typename U = T>
DAW_ATTRIB_INLINE constexpr T daw::exchange ( T &  obj,
U &&  new_value 
)
constexpr

Definition at line 26 of file daw_exchange.h.

◆ expander()

template<typename... Ts>
daw::expander ( Ts...  ) -> expander< Ts... >

◆ expected_from_code() [1/2]

template<typename Result , typename Function , typename... Args>
expected_t< Result > daw::expected_from_code ( Function &&  func,
Args &&...  args 
)

Definition at line 405 of file daw_expected.h.

◆ expected_from_code() [2/2]

template<typename Function , typename... Args>
auto daw::expected_from_code ( Function &&  func,
Args &&...  args 
)

Definition at line 417 of file daw_expected.h.

◆ expected_from_exception() [1/2]

template<typename Result >
expected_t< Result > daw::expected_from_exception ( )

Definition at line 425 of file daw_expected.h.

◆ expected_from_exception() [2/2]

template<typename Result >
expected_t< Result > daw::expected_from_exception ( std::exception_ptr  ptr)

Definition at line 431 of file daw_expected.h.

◆ expecting() [1/2]

template<typename Bool >
DAW_ATTRIB_NOINLINE constexpr void daw::expecting ( Bool const expected_result)
constexpr

Definition at line 625 of file daw_benchmark.h.

◆ expecting() [2/2]

template<typename T , typename U >
DAW_ATTRIB_NOINLINE constexpr void daw::expecting ( T &&  expected_result,
U &&  result 
)
constexpr

Definition at line 610 of file daw_benchmark.h.

◆ expecting_exception()

template<typename Exception = std::exception, typename Expression , typename Predicate = benchmark_impl::always_true, std::enable_if_t< std::is_invocable_v< Predicate, Exception >, std::nullptr_t > = nullptr>
DAW_ATTRIB_NOINLINE void daw::expecting_exception ( Expression &&  expression,
Predicate &&  pred = Predicate{ } 
)

Definition at line 658 of file daw_benchmark.h.

◆ expecting_message()

template<typename Bool , typename String >
DAW_ATTRIB_NOINLINE constexpr void daw::expecting_message ( Bool &&  expected_result,
String &&  message 
)
constexpr

Definition at line 633 of file daw_benchmark.h.

◆ extract_from_container()

template<typename T >
constexpr auto daw::extract_from_container ( T &  container)
constexpr

Definition at line 24 of file daw_container_help_ins_ext.h.

◆ find_all_where() [1/2]

std::vector< Iterator1 > daw::find_all_where ( Iterator1  first,
Iterator2 const  last,
Pred  predicate 
)

Definition at line 286 of file daw_utility.h.

◆ find_all_where() [2/2]

template<typename T , typename Pred >
auto daw::find_all_where ( T const values,
Pred  predicate 
)

Definition at line 293 of file daw_utility.h.

◆ find_iterator() [1/2]

template<typename Iterator , typename Filter >
daw::find_iterator ( Iterator  ,
Filter   
) -> find_iterator< Iterator, Iterator, Filter >

◆ find_iterator() [2/2]

template<typename Iterator , typename IteratorLast , typename Filter >
daw::find_iterator ( Iterator  ,
IteratorLast  ,
Filter   
) -> find_iterator< Iterator, IteratorLast, Filter >

◆ find_one_iterator()

template<typename Iterator , typename IteratorLast , typename Filter >
daw::find_one_iterator ( Iterator  ,
IteratorLast  ,
Filter   
) -> find_one_iterator< Iterator, IteratorLast, Filter >

◆ fixed_array() [1/4]

template<typename Iterator >
daw::fixed_array ( Iterator  ,
std::size_t   
) -> fixed_array< typename std::iterator_traits< Iterator >::value_type >

◆ fixed_array() [2/4]

template<typename... Ts>
daw::fixed_array ( std::in_place_t  ,
Ts...   
) -> fixed_array< std::common_type_t< Ts... > >

◆ fixed_array() [3/4]

template<typename T , typename... Ts>
daw::fixed_array ( std::in_place_type_t< T >  ,
Ts...   
) -> fixed_array< T >

◆ fixed_array() [4/4]

template<typename T >
daw::fixed_array ( std::size_t  ,
 
) -> fixed_array< T >

◆ float_abs()

template<typename Float , std::enable_if_t< std::is_floating_point_v< Float >, std::nullptr_t > = nullptr>
constexpr Float daw::float_abs ( Float  f)
constexpr

Definition at line 28 of file daw_math_impl.h.

◆ fmt_any()

template<typename T >
constexpr decltype(auto) daw::fmt_any ( T &&  v)
constexpr

Definition at line 20 of file daw_formatters.h.

◆ fmt_range() [1/3]

template<Range R>
daw::fmt_range ( ) -> fmt_range< R >

◆ fmt_range() [2/3]

template<Range R, typename CharT >
daw::fmt_range ( ,
CharT const  
) -> fmt_range< R, CharT >

◆ fmt_range() [3/3]

template<Range R, typename CharT >
daw::fmt_range ( ,
CharT const ,
CharT const ,
CharT const  
) -> fmt_range< R, CharT >

◆ fmt_tuple() [1/3]

template<typename T >
daw::fmt_tuple ( ) -> fmt_tuple< T >

◆ fmt_tuple() [2/3]

template<typename T , typename CharT >
daw::fmt_tuple ( ,
CharT const  
) -> fmt_tuple< T, CharT >

◆ fmt_tuple() [3/3]

template<typename T , typename CharT >
daw::fmt_tuple ( ,
CharT const ,
CharT const ,
CharT const  
) -> fmt_tuple< T, CharT >

◆ fnv1a_hash() [1/6]

template<fnv1a_uint_t N>
constexpr fnv1a_uint_t daw::fnv1a_hash ( char const (&)  ptr[N])
constexprnoexcept

Definition at line 194 of file daw_fnv1a_hash.h.

◆ fnv1a_hash() [2/6]

constexpr fnv1a_uint_t daw::fnv1a_hash ( char const ptr)
constexprnoexcept

Definition at line 159 of file daw_fnv1a_hash.h.

◆ fnv1a_hash() [3/6]

template<typename CharT >
constexpr fnv1a_uint_t daw::fnv1a_hash ( CharT const ptr,
std::size_t  len 
)
constexprnoexcept

Definition at line 171 of file daw_fnv1a_hash.h.

◆ fnv1a_hash() [4/6]

template<typename CharT , size_t Capacity>
constexpr size_t daw::fnv1a_hash ( daw::basic_bounded_string< CharT, Capacity > const str)
constexprnoexcept

Definition at line 1339 of file daw_bounded_string.h.

◆ fnv1a_hash() [5/6]

template<typename Integer , std::enable_if_t< std::is_integral_v< Integer >, std::nullptr_t > = nullptr>
constexpr fnv1a_uint_t daw::fnv1a_hash ( Integer  value)
constexprnoexcept

Definition at line 155 of file daw_fnv1a_hash.h.

◆ fnv1a_hash() [6/6]

template<typename StringViewLike , std::enable_if_t< traits_is_sv::is_string_view_like_v< StringViewLike >, std::nullptr_t > = nullptr>
fnv1a_uint_t daw::fnv1a_hash ( StringViewLike &&  sv)

Definition at line 187 of file daw_fnv1a_hash.h.

◆ force_evaluation() [1/2]

template<typename T >
void daw::force_evaluation ( T &  value)
inline

Definition at line 708 of file daw_utility.h.

◆ force_evaluation() [2/2]

template<typename T >
void daw::force_evaluation ( T const value)
inline

Definition at line 703 of file daw_utility.h.

◆ forward_as_tuple()

template<typename... Ts>
constexpr tuple< Ts &&... > daw::forward_as_tuple ( Ts &&...  ts)
constexprnoexcept

Definition at line 225 of file daw_tuple.h.

◆ forward_as_tuple2()

template<typename... Ts>
constexpr tuple2< Ts... > daw::forward_as_tuple2 ( Ts &&...  args)
constexpr

Definition at line 170 of file daw_tuple2.h.

◆ forward_counting_iterator()

template<typename ForwardIterator >
daw::forward_counting_iterator ( ForwardIterator  ) -> forward_counting_iterator< ForwardIterator >

◆ forward_nonrvalue_as_tuple()

template<typename... Ts>
constexpr auto daw::forward_nonrvalue_as_tuple ( Ts &&...  values)
constexpr

Forwards arguments but stores rvalues. This allows use to prevent dangling ref's.

Definition at line 24 of file daw_tuple_forward.h.

◆ forward_nontemp_as_tuple()

template<typename... Ts>
constexpr auto daw::forward_nontemp_as_tuple ( Ts &&...  values)
constexpr

Definition at line 508 of file daw_tuple_helper.h.

◆ forward_nth_pack_element()

template<std::size_t Idx, typename... Ts>
constexpr decltype(auto) daw::forward_nth_pack_element ( Ts &&...  values)
constexpr

Definition at line 38 of file daw_nth_pack_element.h.

◆ function_iterator()

◆ fwd_pack()

template<typename... Ts>
daw::fwd_pack ( Ts &&  ...) -> fwd_pack< Ts &&... >

◆ generic_hash() [1/7]

template<size_t HashBytes = sizeof( genhash_uint_t ), std::size_t N>
constexpr auto daw::generic_hash ( char const (&)  ptr[N])
constexprnoexcept

Definition at line 232 of file daw_generic_hash.h.

◆ generic_hash() [2/7]

template<size_t HashSize = sizeof( size_t ), typename CharT , size_t Capacity>
constexpr size_t daw::generic_hash ( daw::basic_bounded_string< CharT, Capacity > const str)
constexprnoexcept

Definition at line 1344 of file daw_bounded_string.h.

◆ generic_hash() [3/7]

template<size_t HashSize = sizeof( size_t ), typename CharT , size_t Capacity>
constexpr size_t daw::generic_hash ( daw::basic_bounded_string< CharT, Capacity sv)
constexprnoexcept

Definition at line 1372 of file daw_bounded_string.h.

◆ generic_hash() [4/7]

template<size_t HashBytes = sizeof( genhash_uint_t ), typename Iterator , typename IteratorL >
constexpr auto daw::generic_hash ( Iterator  first,
IteratorL const  last 
)
constexprnoexcept

Definition at line 202 of file daw_generic_hash.h.

◆ generic_hash() [5/7]

template<size_t HashBytes = sizeof( genhash_uint_t ), typename Iterator >
constexpr auto daw::generic_hash ( Iterator  first,
std::size_t const  len 
)
constexprnoexcept

Definition at line 213 of file daw_generic_hash.h.

◆ generic_hash() [6/7]

template<size_t HashBytes = sizeof( genhash_uint_t ), typename StringViewLike , std::enable_if_t< traits_is_sv::is_string_view_like_v< StringViewLike >, std::nullptr_t > = nullptr>
auto daw::generic_hash ( StringViewLike const &&  sv)
noexcept

Definition at line 227 of file daw_generic_hash.h.

◆ generic_hash() [7/7]

template<size_t HashBytes = sizeof( genhash_uint_t ), typename T , std::enable_if_t< std::is_integral_v< T >, std::nullptr_t > = nullptr>
constexpr auto daw::generic_hash ( T const  value)
constexprnoexcept

Definition at line 196 of file daw_generic_hash.h.

◆ get() [1/18]

template<std::size_t Idx, typename... Ts>
constexpr decltype(auto) daw::get ( fwd_pack< Ts... > &&  p)
constexpr

Definition at line 93 of file daw_fwd_pack_apply.h.

◆ get() [2/18]

template<std::size_t Idx, typename... Ts>
constexpr decltype(auto) daw::get ( fwd_pack< Ts... > &  p)
constexpr

Definition at line 98 of file daw_fwd_pack_apply.h.

◆ get() [3/18]

template<std::size_t Idx, typename... Ts>
constexpr decltype(auto) daw::get ( fwd_pack< Ts... > const p)
constexpr

Definition at line 104 of file daw_fwd_pack_apply.h.

◆ get() [4/18]

template<typename... Args>
constexpr auto daw::get ( std::tuple< Args... > &  tp,
size_t  index 
)
constexprnoexcept

Definition at line 54 of file daw_tuple_helper.h.

◆ get() [5/18]

template<typename... Args>
constexpr auto daw::get ( std::tuple< Args... > const tp,
size_t  index 
)
constexprnoexcept

Definition at line 61 of file daw_tuple_helper.h.

◆ get() [6/18]

template<std::size_t Index, typename Ts >
constexpr Ts && daw::get ( tuple2_impl::leaf< Index, Ts, false > &&  tp)
constexpr

Definition at line 143 of file daw_tuple2.h.

◆ get() [7/18]

template<std::size_t Index, typename Ts >
constexpr Ts & daw::get ( tuple2_impl::leaf< Index, Ts, false > &  tp)
constexpr

Definition at line 123 of file daw_tuple2.h.

◆ get() [8/18]

template<std::size_t Index, typename Ts >
constexpr Ts const && daw::get ( tuple2_impl::leaf< Index, Ts, false > const &&  tp)
constexpr

Definition at line 133 of file daw_tuple2.h.

◆ get() [9/18]

template<std::size_t Index, typename Ts >
constexpr Ts const & daw::get ( tuple2_impl::leaf< Index, Ts, false > const tp)
constexpr

Definition at line 113 of file daw_tuple2.h.

◆ get() [10/18]

template<std::size_t Index, typename Ts >
constexpr Ts && daw::get ( tuple2_impl::leaf< Index, Ts, true > &&  tp)
constexpr

Definition at line 138 of file daw_tuple2.h.

◆ get() [11/18]

template<std::size_t Index, typename Ts >
constexpr Ts & daw::get ( tuple2_impl::leaf< Index, Ts, true > &  tp)
constexpr

Definition at line 118 of file daw_tuple2.h.

◆ get() [12/18]

template<std::size_t Index, typename Ts >
constexpr Ts const && daw::get ( tuple2_impl::leaf< Index, Ts, true > const &&  tp)
constexpr

Definition at line 128 of file daw_tuple2.h.

◆ get() [13/18]

template<std::size_t Index, typename Ts >
constexpr Ts const & daw::get ( tuple2_impl::leaf< Index, Ts, true > const tp)
constexpr

Definition at line 108 of file daw_tuple2.h.

◆ get() [14/18]

template<std::size_t N, typename... Ts>
constexpr decltype(auto) daw::get ( tuple< Ts... > &&  tp)
constexpr

Definition at line 220 of file daw_tuple.h.

◆ get() [15/18]

template<std::size_t N, typename... Ts>
constexpr decltype(auto) daw::get ( tuple< Ts... > &  tp)
constexpr

Definition at line 215 of file daw_tuple.h.

◆ get() [16/18]

template<std::size_t N, typename... Ts>
constexpr decltype(auto) daw::get ( tuple< Ts... > const tp)
constexpr

Definition at line 210 of file daw_tuple.h.

◆ get() [17/18]

template<size_t N, typename... T>
constexpr decltype(auto) daw::get ( zip_iterator< T... > &  zi)
constexprnoexcept

Definition at line 183 of file daw_zipiter.h.

◆ get() [18/18]

template<size_t N, typename... T>
constexpr decltype(auto) daw::get ( zip_iterator< T... > const zi)
constexprnoexcept

Definition at line 188 of file daw_zipiter.h.

◆ get_bit() [1/4]

template<unsigned N>
constexpr UInt16 daw::get_bit ( UInt16  value)
inlineconstexpr

Definition at line 2913 of file daw_uint_types.h.

◆ get_bit() [2/4]

template<unsigned N>
constexpr UInt32 daw::get_bit ( UInt32  value)
inlineconstexpr

Definition at line 2900 of file daw_uint_types.h.

◆ get_bit() [3/4]

template<unsigned N>
constexpr UInt64 daw::get_bit ( UInt64  value)
inlineconstexpr

Definition at line 2887 of file daw_uint_types.h.

◆ get_bit() [4/4]

template<unsigned N>
constexpr UInt8 daw::get_bit ( UInt8  value)
inlineconstexpr

Definition at line 2925 of file daw_uint_types.h.

◆ get_bits()

template<typename Integer , typename Bit , typename... Bits>
constexpr Integer daw::get_bits ( Integer  i,
Bit  b,
Bits...  bs 
)
constexprnoexcept

get value with all bits but those specified masked out

Definition at line 96 of file daw_bit.h.

◆ get_buffer()

template<typename T , std::size_t Alignment = alignof( T )>
T * daw::get_buffer ( std::size_t  count)
inlinenoexcept

aligned_alloc is not in clang-cl 13 with vs2022

Definition at line 937 of file daw_utility.h.

◆ get_left_mask()

template<typename T >
constexpr T daw::get_left_mask ( size_t  left_zero_bits)
constexprnoexcept

Definition at line 24 of file daw_bit.h.

◆ get_nt()

template<std::size_t Idx, typename Variant >
constexpr decltype(auto) daw::get_nt ( Variant &&  var)
constexpr

Definition at line 54 of file daw_visit.h.

◆ get_right_mask()

template<typename T >
constexpr T daw::get_right_mask ( size_t  right_zero_bits)
constexprnoexcept

Definition at line 38 of file daw_bit.h.

◆ hex() [1/7]

constexpr OutputIterator daw::hex ( char  c,
OutputIterator  it_out 
)
constexprnoexcept

Definition at line 487 of file daw_utility.h.

◆ hex() [2/7]

constexpr OutputIterator daw::hex ( char const (&)  str[N],
OutputIterator  first_out 
)
constexprnoexcept

Definition at line 558 of file daw_utility.h.

◆ hex() [3/7]

constexpr OutputIterator daw::hex ( char const str,
std::size_t  len,
OutputIterator  first_out 
)
constexprnoexcept

Definition at line 549 of file daw_utility.h.

◆ hex() [4/7]

template<typename ForwardIterator1 , typename ForwardIterator2 , typename OutputIterator , std::enable_if_t< std::is_integral_v< typename std::iterator_traits< ForwardIterator1 >::value_type >, std::nullptr_t > = nullptr>
constexpr OutputIterator daw::hex ( ForwardIterator1  first_in,
ForwardIterator2 const  last_in,
OutputIterator  first_out 
)
constexprnoexcept

Definition at line 538 of file daw_utility.h.

◆ hex() [5/7]

template<typename ForwardIterator1 , typename ForwardIterator2 , typename OutputIterator , std::enable_if_t< not std::is_integral_v< typename std::iterator_traits< ForwardIterator1 >::value_type >, std::nullptr_t > = nullptr>
OutputIterator daw::hex ( ForwardIterator1  first_in,
ForwardIterator2 const  last_in,
OutputIterator  first_out 
)
noexcept

Definition at line 568 of file daw_utility.h.

◆ hex() [6/7]

template<typename T , typename OutputIterator , std::enable_if_t< std::is_integral_v< T >, std::nullptr_t > = nullptr>
constexpr OutputIterator daw::hex ( T const val,
OutputIterator  it_out 
)
constexprnoexcept

Definition at line 510 of file daw_utility.h.

◆ hex() [7/7]

template<typename T , typename OutputIterator , std::enable_if_t< not std::is_integral_v< T >, std::nullptr_t > = nullptr>
OutputIterator daw::hex ( T const val,
OutputIterator  it_out 
)
noexcept

Definition at line 521 of file daw_utility.h.

◆ hex_lc()

constexpr OutputIterator daw::hex_lc ( char  c,
OutputIterator  it_out 
)
constexprnoexcept

Definition at line 499 of file daw_utility.h.

◆ ibegin() [1/3]

template<typename T >
constexpr auto daw::ibegin ( T &&  container)
constexprnoexcept

Definition at line 208 of file daw_indexed_iterator.h.

◆ ibegin() [2/3]

template<typename T , size_t N>
constexpr auto daw::ibegin ( T const (&)  container[N])
constexprnoexcept

Definition at line 251 of file daw_indexed_iterator.h.

◆ ibegin() [3/3]

template<typename T , size_t N>
constexpr auto daw::ibegin ( T(&)  container[N])
constexprnoexcept

Definition at line 246 of file daw_indexed_iterator.h.

◆ iend() [1/3]

template<typename T >
constexpr auto daw::iend ( T &&  container)
constexprnoexcept

Definition at line 226 of file daw_indexed_iterator.h.

◆ iend() [2/3]

template<typename T , size_t N>
constexpr auto daw::iend ( T const (&)  container[N])
constexprnoexcept

Definition at line 271 of file daw_indexed_iterator.h.

◆ iend() [3/3]

template<typename T , size_t N>
constexpr auto daw::iend ( T(&)  container[N])
constexprnoexcept

Definition at line 266 of file daw_indexed_iterator.h.

◆ in_range() [1/2]

template<typename R , typename T , std::enable_if_t< daw::is_integral_v< R > and daw::is_integral_v< T >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool daw::in_range ( t)
constexprnoexcept

Definition at line 91 of file daw_int_cmp.h.

◆ in_range() [2/2]

constexpr bool daw::in_range ( Value &&  value,
LowerBound &&  lower,
UpperBound &&  upper 
)
constexprnoexcept

Checks if value is in the range [lower, upper)

Definition at line 810 of file daw_utility.h.

◆ index_of()

constexpr auto daw::index_of ( Container const container,
Item const item 
)
constexprnoexcept

Definition at line 386 of file daw_utility.h.

◆ InputIterator()

template<typename Iterator >
daw::InputIterator ( Iterator  ) -> InputIterator< typename std::iterator_traits< Iterator >::value_type >

◆ InputRange() [1/2]

template<typename Container >
daw::InputRange ( Container  ) -> InputRange< std::remove_reference_t< decltype(*std::begin(std::declval< Container >()))> >

◆ InputRange() [2/2]

template<typename Iterator >
daw::InputRange ( Iterator  ,
Iterator   
) -> InputRange< typename std::iterator_traits< Iterator >::value_type >

◆ insert_into_container()

template<typename Container , typename Allocator , typename Pointer >
constexpr void daw::insert_into_container ( Container vec,
Pointer buff,
Allocator  alloc,
std::size_t  capacity,
std::size_t  size 
)
constexpr

Definition at line 29 of file daw_container_help_ins_ext.h.

◆ inserter()

template<typename Container >
constexpr auto daw::inserter ( Container c)
constexpr

Definition at line 58 of file daw_inserter.h.

◆ invoke() [1/2]

template<typename F , typename... Args, std::enable_if_t< sizeof...(Args) !=1 or((not is_reference_wrapper_v< Args >) and ...), std::nullptr_t > = nullptr>
constexpr decltype(auto) daw::invoke ( F &&  f,
Args &&...  args 
)
constexprnoexcept

Definition at line 106 of file daw_apply.h.

◆ invoke() [2/2]

template<typename F , typename Arg , typename... Args>
constexpr decltype(auto) daw::invoke ( F &&  f,
std::reference_wrapper< Arg arg,
std::reference_wrapper< Args >...  args 
)
constexprnoexcept

Definition at line 113 of file daw_apply.h.

◆ iota_iterator() [1/2]

◆ iota_iterator() [2/2]

template<typename T , typename... Step>
daw::iota_iterator ( ,
Step...   
) -> iota_iterator< T >

◆ iota_range() [1/2]

◆ iota_range() [2/2]

template<typename T , typename... EndStep>
daw::iota_range ( ,
EndStep...   
) -> iota_range< T >

◆ is_space()

constexpr bool daw::is_space ( char  chr)
inlineconstexprnoexcept

Definition at line 280 of file daw_utility.h.

◆ iter_last()

template<typename R >
constexpr auto daw::iter_last ( R &&  r)
constexpr

Definition at line 216 of file daw_iterator_traits.h.

◆ iter_swap()

constexpr void daw::iter_swap ( ForwardIterator1  lhs,
ForwardIterator2  rhs 
)
constexprnoexcept

Definition at line 69 of file daw_swap.h.

◆ iter_view() [1/4]

template<typename Container >
daw::iter_view ( Container  ) -> iter_view< typename Container::iterator >

◆ iter_view() [2/4]

template<typename ForwardIterator , typename Last >
daw::iter_view ( ForwardIterator  ,
Last   
) -> iter_view< ForwardIterator, Last >

◆ iter_view() [3/4]

template<typename T , std::size_t N>
daw::iter_view ( T(&&)  [N]) -> iter_view< T * >

◆ iter_view() [4/4]

template<typename T , std::size_t N>
daw::iter_view ( T(&)  [N]) -> iter_view< T * >

◆ make_array() [1/2]

template<typename T = make_array_impl::unspecified_type, typename... Args, std::enable_if_t< not std::is_same_v< T, void >, std::nullptr_t > = nullptr>
constexpr auto daw::make_array ( Args &&...  args)
constexpr

Definition at line 72 of file daw_array.h.

◆ make_array() [2/2]

template<typename T , size_t N>
constexpr auto daw::make_array ( T const (&&)  arry[N])
constexpr

Definition at line 92 of file daw_array.h.

◆ make_bit_iterator()

template<typename Iterator >
constexpr auto daw::make_bit_iterator ( Iterator &&  it)
constexpr

Create a bit_iterator with supplied bit.

Definition at line 74 of file daw_bit_iterator.h.

◆ make_bit_stream()

template<typename BitQueueLSB = bit_queue_source_native_endian, typename InputIteratorF , typename InputIteratorL >
constexpr auto daw::make_bit_stream ( InputIteratorF  first,
InputIteratorL  last 
)
constexprnoexcept

Definition at line 148 of file daw_bit_stream.h.

◆ make_bounded_hash_map()

template<typename Key , typename Value , typename Hash = std::hash<Key>, size_t N>
DAW_CONSTEVAL auto daw::make_bounded_hash_map ( std::pair< Key, Value > const (&)  items[N])

Definition at line 550 of file daw_bounded_hash_map.h.

◆ make_bounded_hash_set()

template<typename Key , typename Hash = std::hash<Key>, size_t N>
constexpr auto daw::make_bounded_hash_set ( Key const (&)  items[N])
constexprnoexcept

Definition at line 469 of file daw_bounded_hash_set.h.

◆ make_bounded_string() [1/2]

template<size_t Capacity = 100, typename CharT , size_t N>
constexpr daw::basic_bounded_string< CharT, Capacity > daw::make_bounded_string ( CharT const (&)  str[N])
constexpr

Definition at line 785 of file daw_bounded_string.h.

◆ make_bounded_string() [2/2]

template<size_t Capacity = 100, typename Container >
constexpr auto daw::make_bounded_string ( Container const v) -> basic_bounded_string<typename Container::value_type, Capacity>
constexprnoexcept

Definition at line 777 of file daw_bounded_string.h.

◆ make_bounded_string_it() [1/2]

template<size_t Capacity = 100, typename CharT >
constexpr auto daw::make_bounded_string_it ( CharT const first,
CharT const last 
)
constexprnoexcept

Definition at line 760 of file daw_bounded_string.h.

◆ make_bounded_string_it() [2/2]

template<size_t Capacity = 100, typename Iterator , typename CharT = DAW_TYPEOF( *std::declval<Iterator>( ) )>
constexpr auto daw::make_bounded_string_it ( Iterator  first,
Iterator  last 
)
constexprnoexcept

Definition at line 768 of file daw_bounded_string.h.

◆ make_callable() [1/2]

template<typename Function , std::enable_if_t< not std::is_function_v< std::remove_reference_t< Function > >, std::nullptr_t > = nullptr>
constexpr decltype(auto) daw::make_callable ( Function &&  func)
constexprnoexcept

Definition at line 161 of file daw_function.h.

◆ make_callable() [2/2]

template<typename Function , std::enable_if_t< std::is_function_v< Function >, std::nullptr_t > = nullptr>
constexpr auto daw::make_callable ( Function func)
constexprnoexcept

Definition at line 196 of file daw_function.h.

◆ make_checked_function()

template<typename Result , typename... Exceptions, typename Function >
constexpr checked_function_t< Function, Result, Exceptions... > daw::make_checked_function ( Function &&  func)
constexprnoexcept

Definition at line 413 of file daw_checked_expected.h.

◆ make_checked_iterator_proxy()

auto daw::make_checked_iterator_proxy ( IteratorFirst  first,
IteratorLast  last,
bool  CheckIncrement = true,
bool  CheckDecrement = true,
bool  CheckDereference = true 
)

Definition at line 173 of file daw_checked_iterator_proxy.h.

◆ make_circular_iterator() [1/2]

template<typename Container >
constexpr auto daw::make_circular_iterator ( Container container)
constexprnoexcept

Definition at line 235 of file daw_circular_iterator.h.

◆ make_circular_iterator() [2/2]

template<typename Container , typename Iterator >
constexpr auto daw::make_circular_iterator ( Container container,
Iterator  it 
)
constexprnoexcept

Definition at line 240 of file daw_circular_iterator.h.

◆ make_const_random_iterator()

template<typename T >
constexpr auto daw::make_const_random_iterator ( T *const  ptr)
constexprnoexcept

Definition at line 146 of file daw_random_iterator.h.

◆ make_copiable_unique_ptr()

template<typename T , typename... Args>
copiable_unique_ptr< T > daw::make_copiable_unique_ptr ( Args &&...  args)
noexcept

Definition at line 134 of file daw_copiable_unique_ptr.h.

◆ make_fixed_lookup()

template<typename Value , size_t HashSize = sizeof( size_t ), typename... Keys>
constexpr auto daw::make_fixed_lookup ( Keys &&...  keys)
constexprnoexcept

Definition at line 197 of file daw_fixed_lookup.h.

◆ make_formatter()

template<size_t N>
constexpr auto daw::make_formatter ( char const (&)  str[N])
constexpr

Definition at line 110 of file format.h.

◆ make_from_tuple2()

template<class T , class Tuple >
constexpr T daw::make_from_tuple2 ( Tuple &&  t)
constexpr

Definition at line 491 of file daw_tuple_helper.h.

◆ make_function() [1/6]

template<typename L >
constexpr function_traits_t< L > daw::make_function ( L  l)
constexprnoexcept

Definition at line 199 of file daw_utility.h.

◆ make_function() [2/6]

template<typename ReturnType , typename... Args>
std::function< ReturnType(Args...)> daw::make_function ( ReturnType(*)(Args...)  p)

Definition at line 218 of file daw_utility.h.

◆ make_function() [3/6]

template<typename ReturnType , typename... Args>
std::function< daw::traits::root_type_t< ReturnType >(daw::traits::root_type_t< Args >...)> daw::make_function ( ReturnType(*)(Args...)  p)

Definition at line 242 of file daw_utility.h.

◆ make_function() [4/6]

template<typename ReturnType , typename... Args, typename ClassType >
std::function< ReturnType(Args...)> daw::make_function ( ReturnType(ClassType::*)(Args...)  p)

Definition at line 225 of file daw_utility.h.

◆ make_function() [5/6]

template<typename ReturnType , typename... Args, typename ClassType >
std::function< daw::traits::root_type_t< ReturnType >(daw::traits::root_type_t< Args >...)> daw::make_function ( ReturnType(ClassType::*)(Args...)  p)

Definition at line 250 of file daw_utility.h.

◆ make_function() [6/6]

template<typename ReturnType , typename... Args, class T >
auto daw::make_function ( T &&  t) -> std::function< decltype( ReturnType( t( std::declval<Args>( )... ) ) )( Args... )>

Definition at line 210 of file daw_utility.h.

◆ make_function_iterator()

template<typename Function >
constexpr auto daw::make_function_iterator ( Function &&  func)
constexpr

Create a function_iterator with supplied function.

Definition at line 65 of file daw_function_iterator.h.

◆ make_function_table()

template<typename R = void, typename Function , typename... Functions>
constexpr function_table_t< R, Function, Functions... > daw::make_function_table ( Function  fn,
Functions...  fns 
)
constexpr

Definition at line 151 of file daw_function_table.h.

◆ make_initializer_list()

template<typename Arg , typename... Args>
auto daw::make_initializer_list ( Arg &&  arg,
Args &&...  args 
)

Definition at line 368 of file daw_utility.h.

◆ make_mask()

template<typename Bit , typename... Bits>
constexpr auto daw::make_mask ( Bit  bit,
Bits...  bits 
)
constexprnoexcept

Definition at line 51 of file daw_bit.h.

◆ make_move_iterator()

template<typename Iterator >
constexpr std::move_iterator< Iterator > daw::make_move_iterator ( Iterator &&  i)
constexpr

Definition at line 16 of file daw_iterator.h.

◆ make_optional_poly()

template<typename T , typename... Args>
auto daw::make_optional_poly ( Args &&...  args)

Definition at line 175 of file daw_optional_poly.h.

◆ make_output_stream_iterator()

template<typename OutputStream >
constexpr function_iterator< osi_impl::osi_callable< OutputStream > > daw::make_output_stream_iterator ( OutputStream strm)
constexpr

Definition at line 37 of file daw_output_stream_iterator.h.

◆ make_perfect_hash_table()

constexpr auto daw::make_perfect_hash_table ( std::pair< Key, Value > const (&)  data[N])
constexpr

Definition at line 329 of file daw_min_perfect_hash.h.

◆ make_random_data()

template<typename IntType , typename Result = std::vector<IntType>>
Result daw::make_random_data ( std::size_t  count,
IntType  a = lowest_value<IntType>,
IntType  b = max_value<IntType> 
)
inline

Definition at line 94 of file daw_random.h.

◆ make_random_iterator()

template<typename T >
constexpr auto daw::make_random_iterator ( T *const  ptr)
constexprnoexcept

Definition at line 140 of file daw_random_iterator.h.

◆ make_range()

template<typename Iterator >
constexpr auto daw::make_range ( Iterator  first,
Iterator  last 
)
constexprnoexcept

Definition at line 578 of file daw_utility.h.

◆ make_rc_ptr() [1/2]

template<typename T , typename... Args>
DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_single< T > daw::make_rc_ptr ( Args &&...  args)

Definition at line 424 of file daw_ref_counted_pointer.h.

◆ make_rc_ptr() [2/2]

template<typename T >
DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_array< T > daw::make_rc_ptr ( std::size_t  size)

Definition at line 435 of file daw_ref_counted_pointer.h.

◆ make_rc_ptr_for_overwrite() [1/2]

template<typename T , typename... Args>
DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_single< T > daw::make_rc_ptr_for_overwrite ( Args &&  ...)
delete

◆ make_rc_ptr_for_overwrite() [2/2]

template<typename T >
DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_array< T > daw::make_rc_ptr_for_overwrite ( std::size_t  size)

Definition at line 446 of file daw_ref_counted_pointer.h.

◆ make_reverse_iterator()

template<typename Iterator >
constexpr reverse_iterator< Iterator > daw::make_reverse_iterator ( Iterator  i)
constexpr

Definition at line 180 of file daw_reverse_iterator.h.

◆ make_reverse_topological_sorted_range()

template<typename Graph , typename Compare = daw::graph_alg_impl::NoSort>
auto daw::make_reverse_topological_sorted_range ( Graph &&  g,
Compare  c = Compare{ } 
)

Definition at line 453 of file daw_graph_algorithm.h.

◆ make_root_function() [1/2]

template<typename L >
constexpr auto daw::make_root_function ( L  l)
constexprnoexcept

Definition at line 204 of file daw_utility.h.

◆ make_root_function() [2/2]

template<typename ReturnType , typename... Args, class T >
auto daw::make_root_function ( T &&  t) -> std::function<decltype( daw::traits::root_type_t<ReturnType>( t( std::declval<daw::traits::root_type_t<Args>>( )... ) ) )( Args... )>

Definition at line 232 of file daw_utility.h.

◆ make_safe_string() [1/2]

template<typename SanitizeFunction , typename charT , typename traits = std::char_traits<charT>, typename Alloc = std::allocator<charT>>
auto daw::make_safe_string ( charT const *const  unsafe_cstring,
SanitizeFunction &&  sanitize_function 
)

Definition at line 92 of file daw_safe_string.h.

◆ make_safe_string() [2/2]

auto daw::make_safe_string ( std::basic_string< charT, traits, Alloc unsafe_string,
SanitizeFunction &&  sanitize_function 
)

Definition at line 82 of file daw_safe_string.h.

◆ make_sorted_insert_iterator() [1/3]

template<typename... Args, typename Compare = std::less<>>
auto daw::make_sorted_insert_iterator ( std::deque< Args... > &  c,
Compare  compare = Compare{ } 
)

Definition at line 74 of file daw_sorted_insert_iterator.h.

◆ make_sorted_insert_iterator() [2/3]

template<typename... Args, typename Compare = std::less<>>
decltype(auto) daw::make_sorted_insert_iterator ( std::list< Args... > &  c,
Compare  compare = Compare{ } 
)

Definition at line 82 of file daw_sorted_insert_iterator.h.

◆ make_sorted_insert_iterator() [3/3]

template<typename... Args, typename Compare = std::less<>>
auto daw::make_sorted_insert_iterator ( std::vector< Args... > &  c,
Compare  compare = Compare{ } 
)

Definition at line 66 of file daw_sorted_insert_iterator.h.

◆ make_split_it() [1/2]

template<typename CharT , typename Traits , typename Allocator >
constexpr auto daw::make_split_it ( std::basic_string< CharT, Traits, Allocator > &  str,
CharT  divider 
)
constexprnoexcept

Definition at line 588 of file daw_split_iterator.h.

◆ make_split_it() [2/2]

template<typename String , typename Splitter , daw::required< impl::is_splitter_v< Splitter, String > > = nullptr>
constexpr auto daw::make_split_it ( String sv,
Splitter &&  splitter 
)
constexprnoexcept

Definition at line 579 of file daw_split_iterator.h.

◆ make_std_function()

template<typename ReturnType , typename... Args, typename ClassType >
std::function< ReturnType(Args...)> daw::make_std_function ( ReturnType(ClassType::*)(Args...)  p)

Definition at line 258 of file daw_utility.h.

◆ make_string_array()

template<typename... Ts>
std::array< std::string, sizeof...(Ts)> daw::make_string_array ( Ts &&...  t)

Definition at line 98 of file daw_array.h.

◆ make_topological_sorted_range()

template<typename Graph , typename Compare = daw::graph_alg_impl::NoSort>
auto daw::make_topological_sorted_range ( Graph &&  g,
Compare  c = Compare{ } 
)

Definition at line 413 of file daw_graph_algorithm.h.

◆ make_tuple()

template<typename... Ts>
constexpr tuple< make_tuple_details::unwrap_decay_t< Ts >... > daw::make_tuple ( Ts &&...  args)
constexpr

Definition at line 252 of file daw_tuple.h.

◆ make_unique() [1/2]

template<typename T , typename... Args>
DAW_CPP20_CX_ALLOC auto daw::make_unique ( Args &&...  args) -> std::enable_if_t<not std::is_array_v<T>, unique_ptr<T>>

Definition at line 394 of file daw_unique_ptr.h.

◆ make_unique() [2/2]

template<typename T >
DAW_CPP20_CX_ALLOC auto daw::make_unique ( std::size_t  count) -> std::enable_if_t<std::is_array_v<T>, unique_ptr<T>>

Definition at line 410 of file daw_unique_ptr.h.

◆ make_unique_array()

template<typename T , typename... Elements>
DAW_CPP20_CX_ALLOC auto daw::make_unique_array ( Elements &&...  elements) -> std::enable_if_t<std::is_array_v<T>, unique_ptr<T>>

Definition at line 420 of file daw_unique_ptr.h.

◆ make_unique_for_overwrite()

template<typename T >
DAW_CPP20_CX_ALLOC auto daw::make_unique_for_overwrite ( ) -> std::enable_if_t<not std::is_array_v<T>, unique_ptr<T>>

Definition at line 404 of file daw_unique_ptr.h.

◆ make_void_function()

template<typename Function >
constexpr auto daw::make_void_function ( Function &&  func)
constexprnoexcept

Definition at line 288 of file daw_traits_impl.h.

◆ make_zipcontainer()

template<typename... Containers>
zip_container< Containers... > daw::make_zipcontainer ( Containers &&...  args)

Definition at line 62 of file daw_zipcontainer.h.

◆ mask_lsb()

template<typename T >
constexpr T daw::mask_lsb ( size_t  bit_count)
constexprnoexcept

Definition at line 43 of file daw_bit.h.

◆ mask_msb()

template<typename T >
constexpr T daw::mask_msb ( size_t  bit_count)
constexprnoexcept

Definition at line 29 of file daw_bit.h.

◆ max()

template<typename T , typename... Ts>
constexpr auto() daw::max ( T const val1,
Ts const &...  vs 
)
constexprnoexcept

Definition at line 36 of file daw_math_impl.h.

◆ max_comp()

template<typename T , typename Compare = math_impl::less>
constexpr decltype(auto) daw::max_comp ( T &&  lhs,
T &&  rhs,
Compare &&  comp = Compare{ } 
)
constexpr

Definition at line 67 of file daw_math_impl.h.

◆ min()

template<typename T , typename... Ts>
constexpr auto() daw::min ( T const val1,
Ts const &...  vs 
)
constexprnoexcept

Definition at line 76 of file daw_math_impl.h.

◆ min_comp()

template<typename T , typename Compare = math_impl::less>
constexpr decltype(auto) daw::min_comp ( T &&  lhs,
T &&  rhs,
Compare &&  comp = Compare{ } 
)
constexpr

Definition at line 58 of file daw_math_impl.h.

◆ move()

template<typename T >
constexpr daw::traits::remove_reference_t< T > && daw::move ( T &&  value)
inlineconstexprnoexcept

Convert a value to an rvalue.

Parameters
valueA thing of arbitrary type.
Returns
The parameter cast to an rvalue-reference to allow moving it.

Definition at line 26 of file daw_move.h.

◆ move_n()

template<typename Iterator , typename OutputIterator >
constexpr OutputIterator daw::move_n ( Iterator  first,
std::size_t  sz,
OutputIterator  out_it 
)
constexprnoexcept

Definition at line 212 of file daw_vector.h.

◆ move_only()

template<typename T >
daw::move_only ( ) -> move_only< T >

◆ mst()

template<typename T , typename Compare = daw::graph_alg_impl::NoSort>
void daw::mst ( daw::graph_t< T > &  graph,
Compare  = Compare{ } 
)

Definition at line 198 of file daw_graph_algorithm.h.

◆ mutable_capture()

template<typename T >
daw::mutable_capture ( ) -> mutable_capture< T >

◆ narrow_cast()

template<typename Integer , typename... Ts, typename T >
constexpr Integer daw::narrow_cast ( value)
constexpr

Definition at line 869 of file daw_utility.h.

◆ network_to_host_endian()

template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>
constexpr T daw::network_to_host_endian ( value)
constexprnoexcept

Definition at line 134 of file daw_endian.h.

◆ next()

template<typename Iterator >
constexpr Iterator daw::next ( Iterator  it,
ptrdiff_t  n = 1 
)
constexprnoexcept

Move iterator forward n steps, if n < 0 it is only defined for types that are Bidirectional.

Template Parameters
IteratorType of iterator to move forward
Parameters
itIterator to advance
nhow far to move forward
Returns
The resulting iterator of advancing it n steps

Definition at line 124 of file cpp_17_iterator.h.

◆ none_of_f()

template<typename... Ts>
constexpr auto daw::none_of_f ( Ts &&...  needles)
constexprnoexcept

Definition at line 83 of file daw_view_tags.h.

◆ Not()

template<typename Function >
constexpr utility_details::NotImpl< Function > daw::Not ( Function  func)
inlineconstexpr

Definition at line 154 of file daw_utility.h.

◆ not_fn() [1/2]

template<typename Function >
constexpr auto daw::not_fn ( )
constexpr

Definition at line 93 of file cpp_17.h.

◆ not_fn() [2/2]

template<typename Function >
constexpr auto daw::not_fn ( Function &&  func)
constexpr

Definition at line 87 of file cpp_17.h.

◆ not_null() [1/4]

◆ not_null() [2/4]

◆ not_null() [3/4]

◆ not_null() [4/4]

◆ nsc_and()

template<typename Bool , typename... Bools>
DAW_ATTRIB_INLINE constexpr bool daw::nsc_and ( Bool  lhs,
Bools...  rhs 
)
constexprnoexcept

Explicitly do a non-short circuiting logical and with bitwise and.

Definition at line 17 of file daw_logic.h.

◆ nsc_or()

template<typename Bool , typename... Bools>
DAW_ATTRIB_INLINE constexpr bool daw::nsc_or ( Bool  lhs,
Bools...  rhs 
)
constexprnoexcept

Explicitly do a non-short circuiting logical or with bitwise or.

Definition at line 24 of file daw_logic.h.

◆ nth_pack_element()

template<std::size_t Idx, typename... Ts>
constexpr auto daw::nth_pack_element ( Ts &&...  values)
constexpr

Definition at line 31 of file daw_nth_pack_element.h.

◆ observer_ptr()

template<typename P >
daw::observer_ptr ( P ) -> observer_ptr< P >

◆ offset_of()

template<typename Obj , typename T >
constexpr std::size_t daw::offset_of ( T Obj::*  Mem)
constexpr

Definition at line 17 of file daw_cx_offset_of.h.

◆ on_exit_success()

◆ on_scope_exit()

template<typename FunctionType >
DAW_ATTRIB_INLINE constexpr ScopeGuard< FunctionType > daw::on_scope_exit ( FunctionType  f)
constexprnoexcept

Definition at line 88 of file daw_scope_guard.h.

◆ operator!() [1/4]

constexpr bool daw::operator! ( UInt16  value)
constexpr

Definition at line 2406 of file daw_uint_types.h.

◆ operator!() [2/4]

constexpr bool daw::operator! ( UInt32  value)
constexpr

Definition at line 2122 of file daw_uint_types.h.

◆ operator!() [3/4]

constexpr bool daw::operator! ( UInt64  value)
constexpr

Definition at line 1738 of file daw_uint_types.h.

◆ operator!() [4/4]

constexpr bool daw::operator! ( UInt8  value)
constexpr

Definition at line 2603 of file daw_uint_types.h.

◆ operator!=() [1/51]

template<typename T , typename U , size_t N>
constexpr bool daw::operator!= ( array< T, N > const lhs,
array< U, N > const rhs 
)
constexpr

Definition at line 109 of file daw_bounded_array.h.

◆ operator!=() [2/51]

template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool daw::operator!= ( basic_bounded_string< CharT, CapacityL > const lhs,
basic_bounded_string< CharT, CapacityR > const rhs 
)
constexprnoexcept

Definition at line 801 of file daw_bounded_string.h.

◆ operator!=() [3/51]

Definition at line 276 of file daw_bounded_hash_map.h.

◆ operator!=() [4/51]

Definition at line 290 of file daw_bounded_hash_map.h.

◆ operator!=() [5/51]

template<typename Key >
constexpr bool daw::operator!= ( bounded_hash_set_iterator< Key > const lhs,
bounded_hash_set_iterator< Key > const rhs 
)
constexprnoexcept

Definition at line 254 of file daw_bounded_hash_set.h.

◆ operator!=() [6/51]

Definition at line 268 of file daw_bounded_hash_set.h.

◆ operator!=() [7/51]

template<typename CharT , size_t Capacity, size_t N>
constexpr bool daw::operator!= ( CharT const (&)  lhs[N],
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1203 of file daw_bounded_string.h.

◆ operator!=() [8/51]

Definition at line 297 of file daw_bounded_hash_map.h.

◆ operator!=() [9/51]

Definition at line 283 of file daw_bounded_hash_map.h.

◆ operator!=() [10/51]

Definition at line 275 of file daw_bounded_hash_set.h.

◆ operator!=() [11/51]

Definition at line 261 of file daw_bounded_hash_set.h.

◆ operator!=() [12/51]

constexpr bool daw::operator!= ( copiable_unique_ptr< T1, D1 > const lhs,
copiable_unique_ptr< T2, D2 > const rhs 
)
constexprnoexcept

Definition at line 160 of file daw_copiable_unique_ptr.h.

◆ operator!=() [13/51]

constexpr bool daw::operator!= ( copiable_unique_ptr< T1, D1 > const lhs,
std::nullptr_t   
)
constexprnoexcept

Definition at line 167 of file daw_copiable_unique_ptr.h.

◆ operator!=() [14/51]

template<typename CharT , size_t Capacity, size_t N>
constexpr bool daw::operator!= ( daw::basic_bounded_string< CharT, Capacity > const lhs,
CharT const (&)  rhs[N] 
)
constexprnoexcept

Definition at line 1152 of file daw_bounded_string.h.

◆ operator!=() [15/51]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator!= ( daw::basic_bounded_string< CharT, Capacity > const lhs,
daw::sv1::basic_string_view< CharT >  rhs 
)
constexprnoexcept

Definition at line 851 of file daw_bounded_string.h.

◆ operator!=() [16/51]

template<typename CharT , size_t Capacity>
bool daw::operator!= ( daw::basic_bounded_string< CharT, Capacity > const lhs,
std::basic_string< CharT > const rhs 
)
noexcept

Definition at line 950 of file daw_bounded_string.h.

◆ operator!=() [17/51]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator!= ( daw::basic_bounded_string< CharT, Capacity > const lhs,
typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  rhs 
)
constexprnoexcept

Definition at line 1047 of file daw_bounded_string.h.

◆ operator!=() [18/51]

template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool daw::operator!= ( daw::not_null< Lhs > const lhs,
daw::not_null< Rhs > const rhs 
)
constexprnoexcept

Definition at line 286 of file daw_not_null.h.

◆ operator!=() [19/51]

template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool daw::operator!= ( daw::not_null< Pointer > const lhs,
Pointer const rhs 
)
constexprnoexcept

Definition at line 293 of file daw_not_null.h.

◆ operator!=() [20/51]

template<typename T >
bool daw::operator!= ( daw::optional_poly< T > const lhs,
daw::optional_poly< T > const rhs 
)

Definition at line 194 of file daw_optional_poly.h.

◆ operator!=() [21/51]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator!= ( daw::sv1::basic_string_view< CharT > const lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 901 of file daw_bounded_string.h.

◆ operator!=() [22/51]

Definition at line 262 of file daw_hash_table.h.

◆ operator!=() [23/51]

template<typename T , typename U >
bool daw::operator!= ( heap_value< T > const lhs,
heap_value< U > const rhs 
)

Definition at line 129 of file deprecated/daw_heap_value.h.

◆ operator!=() [24/51]

template<typename T , typename U , std::enable_if_t< not std::is_convertible_v< T, U >, std::nullptr_t > = nullptr>
constexpr bool daw::operator!= ( indexed_iterator< T > const ,
indexed_iterator< U > const  
)
constexprnoexcept

Definition at line 310 of file daw_indexed_iterator.h.

◆ operator!=() [25/51]

template<typename T >
constexpr bool daw::operator!= ( indexed_iterator< T > const lhs,
indexed_iterator< T > const rhs 
)
constexprnoexcept

Definition at line 301 of file daw_indexed_iterator.h.

◆ operator!=() [26/51]

template<typename T , typename U >
constexpr bool daw::operator!= ( natural_t< T > const lhs,
natural_t< U > const rhs 
)
constexprnoexcept

Definition at line 187 of file daw_natural.h.

◆ operator!=() [27/51]

constexpr bool daw::operator!= ( node_id_t const lhs,
node_id_t const rhs 
)
constexprnoexcept

Definition at line 77 of file daw_bounded_graph.h.

◆ operator!=() [28/51]

template<typename T , typename U >
constexpr bool daw::operator!= ( optional< T > const lhs,
optional< U > const rhs 
)
constexpr

Definition at line 264 of file daw_optional.h.

◆ operator!=() [29/51]

template<typename T >
constexpr bool daw::operator!= ( optional< T > const opt,
std::nullopt_t   
)
constexprnoexcept

Definition at line 329 of file daw_optional.h.

◆ operator!=() [30/51]

template<typename T , typename U >
constexpr bool daw::operator!= ( optional< T > const opt,
U const value 
)
constexpr

Definition at line 398 of file daw_optional.h.

◆ operator!=() [31/51]

template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool daw::operator!= ( Pointer const lhs,
daw::not_null< Pointer > const rhs 
)
constexprnoexcept

Definition at line 299 of file daw_not_null.h.

◆ operator!=() [32/51]

template<typename T >
bool daw::operator!= ( Reference< T > const lhs,
Reference< T > const rhs 
)

Definition at line 46 of file daw_reference.h.

◆ operator!=() [33/51]

template<typename CharT >
constexpr bool daw::operator!= ( repeat_n_char_iterator< CharT > const lhs,
repeat_n_char_iterator< CharT > const rhs 
)
constexprnoexcept

Definition at line 119 of file daw_repeat_n_char_iterator.h.

◆ operator!=() [34/51]

Definition at line 150 of file daw_reverse_iterator.h.

◆ operator!=() [35/51]

template<typename Iterator >
constexpr bool daw::operator!= ( splitter_range_t< Iterator > const lhs,
splitter_range_t< Iterator > const rhs 
)
constexprnoexcept

Definition at line 87 of file daw_split_iterator.h.

◆ operator!=() [36/51]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator!= ( std::basic_string< CharT > const lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 996 of file daw_bounded_string.h.

◆ operator!=() [37/51]

template<typename T >
constexpr bool daw::operator!= ( std::nullopt_t  ,
optional< T > const opt 
)
constexprnoexcept

Definition at line 334 of file daw_optional.h.

◆ operator!=() [38/51]

constexpr bool daw::operator!= ( std::nullptr_t  ,
copiable_unique_ptr< T2, D2 > const rhs 
)
constexprnoexcept

Definition at line 174 of file daw_copiable_unique_ptr.h.

◆ operator!=() [39/51]

constexpr bool daw::operator!= ( std::uint16_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1305 of file daw_uint_types.h.

◆ operator!=() [40/51]

constexpr bool daw::operator!= ( std::uint32_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 994 of file daw_uint_types.h.

◆ operator!=() [41/51]

constexpr bool daw::operator!= ( std::uint64_t  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 412 of file daw_uint_types.h.

◆ operator!=() [42/51]

constexpr bool daw::operator!= ( std::uint8_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2858 of file daw_uint_types.h.

◆ operator!=() [43/51]

template<typename CharT >
constexpr bool daw::operator!= ( string_split_iterator< CharT > const lhs,
string_split_iterator< CharT > const rhs 
)
constexprnoexcept

Definition at line 109 of file daw_string_split_range.h.

◆ operator!=() [44/51]

template<typename T , typename U >
constexpr bool daw::operator!= ( T const value,
optional< U > const opt 
)
constexpr

Definition at line 406 of file daw_optional.h.

◆ operator!=() [45/51]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator!= ( typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1101 of file daw_bounded_string.h.

◆ operator!=() [46/51]

constexpr bool daw::operator!= ( UInt16  lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 1299 of file daw_uint_types.h.

◆ operator!=() [47/51]

constexpr bool daw::operator!= ( UInt32  lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 988 of file daw_uint_types.h.

◆ operator!=() [48/51]

constexpr bool daw::operator!= ( UInt64  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 407 of file daw_uint_types.h.

◆ operator!=() [49/51]

constexpr bool daw::operator!= ( UInt8  lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2852 of file daw_uint_types.h.

◆ operator!=() [50/51]

template<typename T , typename D0 , typename D1 = D0>
constexpr bool daw::operator!= ( unique_ptr< T, D0 > const lhs,
unique_ptr< T, D1 > const rhs 
)
constexprnoexcept

Definition at line 437 of file daw_unique_ptr.h.

◆ operator!=() [51/51]

template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_inequality< T, U >, std::nullptr_t > = nullptr>
constexpr bool daw::operator!= ( value_ptr< T > const lhs,
value_ptr< U > const rhs 
)
constexprnoexcept

Definition at line 255 of file daw_value_ptr.h.

◆ operator""_u16()

constexpr UInt16 daw::operator""_u16 ( unsigned long long  value)
constexpr

Definition at line 3326 of file daw_uint_types.h.

◆ operator""_u32()

constexpr UInt32 daw::operator""_u32 ( unsigned long long  value)
constexpr

Definition at line 3320 of file daw_uint_types.h.

◆ operator""_u64()

constexpr UInt64 daw::operator""_u64 ( unsigned long long  value)
constexpr

Definition at line 3316 of file daw_uint_types.h.

◆ operator""_u8()

constexpr UInt8 daw::operator""_u8 ( unsigned long long  value)
constexpr

Definition at line 3332 of file daw_uint_types.h.

◆ operator&() [1/23]

constexpr UInt16 daw::operator& ( std::uint16_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1269 of file daw_uint_types.h.

◆ operator&() [2/23]

constexpr UInt32 daw::operator& ( std::uint32_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 958 of file daw_uint_types.h.

◆ operator&() [3/23]

constexpr UInt64 daw::operator& ( std::uint64_t  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 352 of file daw_uint_types.h.

◆ operator&() [4/23]

constexpr UInt8 daw::operator& ( std::uint8_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2822 of file daw_uint_types.h.

◆ operator&() [5/23]

constexpr UInt16 daw::operator& ( UInt16  lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 1263 of file daw_uint_types.h.

◆ operator&() [6/23]

constexpr UInt16 daw::operator& ( UInt16  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1369 of file daw_uint_types.h.

◆ operator&() [7/23]

constexpr UInt32 daw::operator& ( UInt16  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1040 of file daw_uint_types.h.

◆ operator&() [8/23]

constexpr UInt64 daw::operator& ( UInt16  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 622 of file daw_uint_types.h.

◆ operator&() [9/23]

constexpr UInt16 daw::operator& ( UInt16  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1374 of file daw_uint_types.h.

◆ operator&() [10/23]

constexpr UInt32 daw::operator& ( UInt32  lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 952 of file daw_uint_types.h.

◆ operator&() [11/23]

constexpr UInt32 daw::operator& ( UInt32  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1030 of file daw_uint_types.h.

◆ operator&() [12/23]

constexpr UInt32 daw::operator& ( UInt32  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1025 of file daw_uint_types.h.

◆ operator&() [13/23]

constexpr UInt64 daw::operator& ( UInt32  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 617 of file daw_uint_types.h.

◆ operator&() [14/23]

constexpr UInt32 daw::operator& ( UInt32  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1035 of file daw_uint_types.h.

◆ operator&() [15/23]

constexpr UInt64 daw::operator& ( UInt64  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 347 of file daw_uint_types.h.

◆ operator&() [16/23]

constexpr UInt64 daw::operator& ( UInt64  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 607 of file daw_uint_types.h.

◆ operator&() [17/23]

constexpr UInt64 daw::operator& ( UInt64  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 602 of file daw_uint_types.h.

◆ operator&() [18/23]

constexpr UInt64 daw::operator& ( UInt64  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 597 of file daw_uint_types.h.

◆ operator&() [19/23]

constexpr UInt64 daw::operator& ( UInt64  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 612 of file daw_uint_types.h.

◆ operator&() [20/23]

constexpr UInt8 daw::operator& ( UInt8  lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2816 of file daw_uint_types.h.

◆ operator&() [21/23]

constexpr UInt32 daw::operator& ( UInt8  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1045 of file daw_uint_types.h.

◆ operator&() [22/23]

constexpr UInt64 daw::operator& ( UInt8  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 627 of file daw_uint_types.h.

◆ operator&() [23/23]

constexpr UInt8 daw::operator& ( UInt8  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2869 of file daw_uint_types.h.

◆ operator&=() [1/14]

constexpr UInt16 & daw::operator&= ( UInt16 lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 1207 of file daw_uint_types.h.

◆ operator&=() [2/14]

constexpr UInt16 & daw::operator&= ( UInt16 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1215 of file daw_uint_types.h.

◆ operator&=() [3/14]

constexpr UInt16 & daw::operator&= ( UInt16 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1222 of file daw_uint_types.h.

◆ operator&=() [4/14]

constexpr UInt32 & daw::operator&= ( UInt32 lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 846 of file daw_uint_types.h.

◆ operator&=() [5/14]

constexpr UInt32 & daw::operator&= ( UInt32 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 861 of file daw_uint_types.h.

◆ operator&=() [6/14]

constexpr UInt32 & daw::operator&= ( UInt32 lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 854 of file daw_uint_types.h.

◆ operator&=() [7/14]

constexpr UInt32 & daw::operator&= ( UInt32 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 868 of file daw_uint_types.h.

◆ operator&=() [8/14]

constexpr UInt64 & daw::operator&= ( UInt64 lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 267 of file daw_uint_types.h.

◆ operator&=() [9/14]

constexpr UInt64 & daw::operator&= ( UInt64 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 288 of file daw_uint_types.h.

◆ operator&=() [10/14]

constexpr UInt64 & daw::operator&= ( UInt64 lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 281 of file daw_uint_types.h.

◆ operator&=() [11/14]

constexpr UInt64 & daw::operator&= ( UInt64 lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 274 of file daw_uint_types.h.

◆ operator&=() [12/14]

constexpr UInt64 & daw::operator&= ( UInt64 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 295 of file daw_uint_types.h.

◆ operator&=() [13/14]

constexpr UInt8 & daw::operator&= ( UInt8 lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2726 of file daw_uint_types.h.

◆ operator&=() [14/14]

constexpr UInt8 & daw::operator&= ( UInt8 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2734 of file daw_uint_types.h.

◆ operator*() [1/27]

constexpr UInt16 daw::operator* ( std::uint16_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2338 of file daw_uint_types.h.

◆ operator*() [2/27]

constexpr UInt32 daw::operator* ( std::uint32_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2038 of file daw_uint_types.h.

◆ operator*() [3/27]

constexpr UInt32 daw::operator* ( std::uint32_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 2033 of file daw_uint_types.h.

◆ operator*() [4/27]

constexpr UInt32 daw::operator* ( std::uint32_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2043 of file daw_uint_types.h.

◆ operator*() [5/27]

constexpr UInt64 daw::operator* ( std::uint64_t  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1617 of file daw_uint_types.h.

◆ operator*() [6/27]

constexpr UInt8 daw::operator* ( std::uint8_t  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 2564 of file daw_uint_types.h.

◆ operator*() [7/27]

constexpr UInt16 daw::operator* ( UInt16  lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 2328 of file daw_uint_types.h.

◆ operator*() [8/27]

constexpr UInt16 daw::operator* ( UInt16  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2314 of file daw_uint_types.h.

◆ operator*() [9/27]

constexpr UInt32 daw::operator* ( UInt16  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 2019 of file daw_uint_types.h.

◆ operator*() [10/27]

constexpr UInt64 daw::operator* ( UInt16  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1602 of file daw_uint_types.h.

◆ operator*() [11/27]

constexpr UInt16 daw::operator* ( UInt16  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2319 of file daw_uint_types.h.

◆ operator*() [12/27]

constexpr UInt32 daw::operator* ( UInt32  lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 2029 of file daw_uint_types.h.

◆ operator*() [13/27]

constexpr UInt32 daw::operator* ( UInt32  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2009 of file daw_uint_types.h.

◆ operator*() [14/27]

constexpr UInt32 daw::operator* ( UInt32  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 2004 of file daw_uint_types.h.

◆ operator*() [15/27]

constexpr UInt64 daw::operator* ( UInt32  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1597 of file daw_uint_types.h.

◆ operator*() [16/27]

constexpr UInt32 daw::operator* ( UInt32  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2014 of file daw_uint_types.h.

◆ operator*() [17/27]

constexpr UInt64 daw::operator* ( UInt64  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 1612 of file daw_uint_types.h.

◆ operator*() [18/27]

constexpr UInt64 daw::operator* ( UInt64  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1585 of file daw_uint_types.h.

◆ operator*() [19/27]

constexpr UInt64 daw::operator* ( UInt64  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1579 of file daw_uint_types.h.

◆ operator*() [20/27]

constexpr UInt64 daw::operator* ( UInt64  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1573 of file daw_uint_types.h.

◆ operator*() [21/27]

constexpr UInt64 daw::operator* ( UInt64  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1591 of file daw_uint_types.h.

◆ operator*() [22/27]

constexpr UInt16 daw::operator* ( UInt8  lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 2333 of file daw_uint_types.h.

◆ operator*() [23/27]

constexpr UInt8 daw::operator* ( UInt8  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 2559 of file daw_uint_types.h.

◆ operator*() [24/27]

constexpr UInt16 daw::operator* ( UInt8  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2323 of file daw_uint_types.h.

◆ operator*() [25/27]

constexpr UInt32 daw::operator* ( UInt8  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 2024 of file daw_uint_types.h.

◆ operator*() [26/27]

constexpr UInt64 daw::operator* ( UInt8  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1607 of file daw_uint_types.h.

◆ operator*() [27/27]

constexpr UInt8 daw::operator* ( UInt8  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2553 of file daw_uint_types.h.

◆ operator*=() [1/21]

constexpr std::uint16_t & daw::operator*= ( std::uint16_t &  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2300 of file daw_uint_types.h.

◆ operator*=() [2/21]

constexpr std::uint16_t & daw::operator*= ( std::uint16_t &  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2307 of file daw_uint_types.h.

◆ operator*=() [3/21]

constexpr std::uint32_t & daw::operator*= ( std::uint32_t &  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1992 of file daw_uint_types.h.

◆ operator*=() [4/21]

constexpr std::uint32_t & daw::operator*= ( std::uint32_t &  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1986 of file daw_uint_types.h.

◆ operator*=() [5/21]

constexpr std::uint32_t & daw::operator*= ( std::uint32_t &  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1998 of file daw_uint_types.h.

◆ operator*=() [6/21]

constexpr std::uint64_t & daw::operator*= ( std::uint64_t &  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1567 of file daw_uint_types.h.

◆ operator*=() [7/21]

constexpr std::uint8_t & daw::operator*= ( std::uint8_t &  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2547 of file daw_uint_types.h.

◆ operator*=() [8/21]

constexpr UInt16 & daw::operator*= ( UInt16 lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 2295 of file daw_uint_types.h.

◆ operator*=() [9/21]

constexpr UInt16 & daw::operator*= ( UInt16 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2283 of file daw_uint_types.h.

◆ operator*=() [10/21]

constexpr UInt16 & daw::operator*= ( UInt16 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2289 of file daw_uint_types.h.

◆ operator*=() [11/21]

constexpr UInt32 & daw::operator*= ( UInt32 lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 1981 of file daw_uint_types.h.

◆ operator*=() [12/21]

constexpr UInt32 & daw::operator*= ( UInt32 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1969 of file daw_uint_types.h.

◆ operator*=() [13/21]

constexpr UInt32 & daw::operator*= ( UInt32 lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1963 of file daw_uint_types.h.

◆ operator*=() [14/21]

constexpr UInt32 & daw::operator*= ( UInt32 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1975 of file daw_uint_types.h.

◆ operator*=() [15/21]

constexpr UInt64 & daw::operator*= ( UInt64 lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 1562 of file daw_uint_types.h.

◆ operator*=() [16/21]

constexpr UInt64 & daw::operator*= ( UInt64 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1550 of file daw_uint_types.h.

◆ operator*=() [17/21]

constexpr UInt64 & daw::operator*= ( UInt64 lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1544 of file daw_uint_types.h.

◆ operator*=() [18/21]

constexpr UInt64 & daw::operator*= ( UInt64 lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1538 of file daw_uint_types.h.

◆ operator*=() [19/21]

constexpr UInt64 & daw::operator*= ( UInt64 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1556 of file daw_uint_types.h.

◆ operator*=() [20/21]

constexpr UInt8 & daw::operator*= ( UInt8 lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2542 of file daw_uint_types.h.

◆ operator*=() [21/21]

constexpr UInt8 & daw::operator*= ( UInt8 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2536 of file daw_uint_types.h.

◆ operator+() [1/44]

template<typename CharT , size_t Capacity>
auto daw::operator+ ( CharT const lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)

Definition at line 1256 of file daw_bounded_string.h.

◆ operator+() [2/44]

template<typename CharT , size_t N, size_t Capacity>
auto daw::operator+ ( CharT(&)  lhs[N],
daw::basic_bounded_string< CharT, Capacity > const rhs 
)

Definition at line 1247 of file daw_bounded_string.h.

◆ operator+() [3/44]

template<typename T >
not_null< T > daw::operator+ ( const not_null< T > &  ,
std::ptrdiff_t   
)
delete

◆ operator+() [4/44]

template<typename CharT , size_t Capacity>
auto daw::operator+ ( daw::basic_bounded_string< CharT, Capacity lhs,
CharT const rhs 
)

Definition at line 1288 of file daw_bounded_string.h.

◆ operator+() [5/44]

template<typename CharT , size_t Capacity, size_t N>
auto daw::operator+ ( daw::basic_bounded_string< CharT, Capacity lhs,
CharT(&)  rhs[N] 
)

Definition at line 1280 of file daw_bounded_string.h.

◆ operator+() [6/44]

template<typename CharT , size_t Capacity, typename Allocator >
auto daw::operator+ ( daw::basic_bounded_string< CharT, Capacity lhs,
std::basic_string< CharT, Allocator > &&  rhs 
)

Definition at line 1272 of file daw_bounded_string.h.

◆ operator+() [7/44]

template<typename CharT , size_t Capacity, typename Allocator >
auto daw::operator+ ( daw::basic_bounded_string< CharT, Capacity lhs,
std::basic_string< CharT, Allocator > const rhs 
)

Definition at line 1265 of file daw_bounded_string.h.

◆ operator+() [8/44]

template<typename CharT , size_t Capacity, typename Allocator >
auto daw::operator+ ( std::basic_string< CharT, Allocator >  lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)

Appending.

Definition at line 1239 of file daw_bounded_string.h.

◆ operator+() [9/44]

constexpr wrap_iter< Iterator1, Tag > daw::operator+ ( std::ptrdiff_t  n,
wrap_iter< Iterator1, Tag x 
)
constexprnoexcept

Definition at line 127 of file wrap_iter.h.

◆ operator+() [10/44]

template<typename T >
not_null< T > daw::operator+ ( std::ptrdiff_t  ,
const not_null< T > &   
)
delete

◆ operator+() [11/44]

constexpr UInt16 daw::operator+ ( std::uint16_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2218 of file daw_uint_types.h.

◆ operator+() [12/44]

constexpr UInt32 daw::operator+ ( std::uint32_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1864 of file daw_uint_types.h.

◆ operator+() [13/44]

constexpr UInt32 daw::operator+ ( std::uint32_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1859 of file daw_uint_types.h.

◆ operator+() [14/44]

constexpr UInt32 daw::operator+ ( std::uint32_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1869 of file daw_uint_types.h.

◆ operator+() [15/44]

constexpr UInt64 daw::operator+ ( std::uint64_t  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1458 of file daw_uint_types.h.

◆ operator+() [16/44]

constexpr UInt8 daw::operator+ ( std::uint8_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2496 of file daw_uint_types.h.

◆ operator+() [17/44]

template<typename Iterator >
constexpr reverse_iterator< Iterator > daw::operator+ ( typename reverse_iterator< Iterator >::difference_type  n,
reverse_iterator< Iterator > const it 
)
constexpr

Definition at line 121 of file daw_reverse_iterator.h.

◆ operator+() [18/44]

constexpr UInt16 daw::operator+ ( UInt16  lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 2209 of file daw_uint_types.h.

◆ operator+() [19/44]

constexpr UInt32 daw::operator+ ( UInt16  lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 1851 of file daw_uint_types.h.

◆ operator+() [20/44]

constexpr UInt16 daw::operator+ ( UInt16  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2192 of file daw_uint_types.h.

◆ operator+() [21/44]

constexpr UInt32 daw::operator+ ( UInt16  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1836 of file daw_uint_types.h.

◆ operator+() [22/44]

constexpr UInt64 daw::operator+ ( UInt16  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1444 of file daw_uint_types.h.

◆ operator+() [23/44]

constexpr UInt16 daw::operator+ ( UInt16  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2198 of file daw_uint_types.h.

◆ operator+() [24/44]

constexpr UInt16 daw::operator+ ( UInt16  value)
constexpr

Definition at line 2410 of file daw_uint_types.h.

◆ operator+() [25/44]

constexpr UInt32 daw::operator+ ( UInt32  lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 1846 of file daw_uint_types.h.

◆ operator+() [26/44]

constexpr UInt32 daw::operator+ ( UInt32  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1824 of file daw_uint_types.h.

◆ operator+() [27/44]

constexpr UInt32 daw::operator+ ( UInt32  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1818 of file daw_uint_types.h.

◆ operator+() [28/44]

constexpr UInt64 daw::operator+ ( UInt32  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1440 of file daw_uint_types.h.

◆ operator+() [29/44]

constexpr UInt32 daw::operator+ ( UInt32  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1830 of file daw_uint_types.h.

◆ operator+() [30/44]

constexpr UInt32 daw::operator+ ( UInt32  value)
constexpr

Definition at line 2126 of file daw_uint_types.h.

◆ operator+() [31/44]

constexpr UInt64 daw::operator+ ( UInt64  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 1453 of file daw_uint_types.h.

◆ operator+() [32/44]

constexpr UInt64 daw::operator+ ( UInt64  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1432 of file daw_uint_types.h.

◆ operator+() [33/44]

constexpr UInt64 daw::operator+ ( UInt64  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1428 of file daw_uint_types.h.

◆ operator+() [34/44]

constexpr UInt64 daw::operator+ ( UInt64  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1424 of file daw_uint_types.h.

◆ operator+() [35/44]

constexpr UInt64 daw::operator+ ( UInt64  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1436 of file daw_uint_types.h.

◆ operator+() [36/44]

constexpr UInt64 daw::operator+ ( UInt64  value)
constexpr

Definition at line 1742 of file daw_uint_types.h.

◆ operator+() [37/44]

constexpr UInt16 daw::operator+ ( UInt8  lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 2214 of file daw_uint_types.h.

◆ operator+() [38/44]

constexpr UInt32 daw::operator+ ( UInt8  lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 1855 of file daw_uint_types.h.

◆ operator+() [39/44]

constexpr UInt8 daw::operator+ ( UInt8  lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2491 of file daw_uint_types.h.

◆ operator+() [40/44]

constexpr UInt16 daw::operator+ ( UInt8  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2204 of file daw_uint_types.h.

◆ operator+() [41/44]

constexpr UInt32 daw::operator+ ( UInt8  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1841 of file daw_uint_types.h.

◆ operator+() [42/44]

constexpr UInt64 daw::operator+ ( UInt8  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1448 of file daw_uint_types.h.

◆ operator+() [43/44]

constexpr UInt8 daw::operator+ ( UInt8  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2485 of file daw_uint_types.h.

◆ operator+() [44/44]

constexpr UInt8 daw::operator+ ( UInt8  value)
constexpr

Definition at line 2607 of file daw_uint_types.h.

◆ operator++() [1/8]

constexpr UInt16 & daw::operator++ ( UInt16 value)
constexpr

Definition at line 2419 of file daw_uint_types.h.

◆ operator++() [2/8]

constexpr UInt16 daw::operator++ ( UInt16 value,
int   
)
constexpr

Definition at line 2424 of file daw_uint_types.h.

◆ operator++() [3/8]

constexpr UInt32 & daw::operator++ ( UInt32 value)
constexpr

Definition at line 2135 of file daw_uint_types.h.

◆ operator++() [4/8]

constexpr UInt32 daw::operator++ ( UInt32 value,
int   
)
constexpr

Definition at line 2140 of file daw_uint_types.h.

◆ operator++() [5/8]

constexpr UInt64 & daw::operator++ ( UInt64 value)
constexpr

Definition at line 1751 of file daw_uint_types.h.

◆ operator++() [6/8]

constexpr UInt64 daw::operator++ ( UInt64 value,
int   
)
constexpr

Definition at line 1756 of file daw_uint_types.h.

◆ operator++() [7/8]

constexpr UInt8 & daw::operator++ ( UInt8 value)
constexpr

Definition at line 2616 of file daw_uint_types.h.

◆ operator++() [8/8]

constexpr UInt8 daw::operator++ ( UInt8 value,
int   
)
constexpr

Definition at line 2621 of file daw_uint_types.h.

◆ operator+=() [1/21]

constexpr std::uint16_t & daw::operator+= ( std::uint16_t &  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2178 of file daw_uint_types.h.

◆ operator+=() [2/21]

constexpr std::uint16_t & daw::operator+= ( std::uint16_t &  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2185 of file daw_uint_types.h.

◆ operator+=() [3/21]

constexpr std::uint32_t & daw::operator+= ( std::uint32_t &  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1806 of file daw_uint_types.h.

◆ operator+=() [4/21]

constexpr std::uint32_t & daw::operator+= ( std::uint32_t &  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1800 of file daw_uint_types.h.

◆ operator+=() [5/21]

constexpr std::uint32_t & daw::operator+= ( std::uint32_t &  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1812 of file daw_uint_types.h.

◆ operator+=() [6/21]

constexpr std::uint64_t & daw::operator+= ( std::uint64_t &  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1418 of file daw_uint_types.h.

◆ operator+=() [7/21]

constexpr std::uint8_t & daw::operator+= ( std::uint8_t &  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2479 of file daw_uint_types.h.

◆ operator+=() [8/21]

constexpr UInt16 & daw::operator+= ( UInt16 lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 2173 of file daw_uint_types.h.

◆ operator+=() [9/21]

constexpr UInt16 & daw::operator+= ( UInt16 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2161 of file daw_uint_types.h.

◆ operator+=() [10/21]

constexpr UInt16 & daw::operator+= ( UInt16 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2167 of file daw_uint_types.h.

◆ operator+=() [11/21]

constexpr UInt32 & daw::operator+= ( UInt32 lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 1795 of file daw_uint_types.h.

◆ operator+=() [12/21]

constexpr UInt32 & daw::operator+= ( UInt32 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1783 of file daw_uint_types.h.

◆ operator+=() [13/21]

constexpr UInt32 & daw::operator+= ( UInt32 lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1777 of file daw_uint_types.h.

◆ operator+=() [14/21]

constexpr UInt32 & daw::operator+= ( UInt32 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1789 of file daw_uint_types.h.

◆ operator+=() [15/21]

constexpr UInt64 & daw::operator+= ( UInt64 lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 1413 of file daw_uint_types.h.

◆ operator+=() [16/21]

constexpr UInt64 & daw::operator+= ( UInt64 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1401 of file daw_uint_types.h.

◆ operator+=() [17/21]

constexpr UInt64 & daw::operator+= ( UInt64 lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1395 of file daw_uint_types.h.

◆ operator+=() [18/21]

constexpr UInt64 & daw::operator+= ( UInt64 lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1389 of file daw_uint_types.h.

◆ operator+=() [19/21]

constexpr UInt64 & daw::operator+= ( UInt64 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1407 of file daw_uint_types.h.

◆ operator+=() [20/21]

constexpr UInt8 & daw::operator+= ( UInt8 lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2474 of file daw_uint_types.h.

◆ operator+=() [21/21]

constexpr UInt8 & daw::operator+= ( UInt8 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2468 of file daw_uint_types.h.

◆ operator-() [1/36]

template<typename T , typename U >
std::ptrdiff_t daw::operator- ( const not_null< T > &  ,
const not_null< U > &   
)
delete

◆ operator-() [2/36]

template<typename T >
not_null< T > daw::operator- ( const not_null< T > &  ,
std::ptrdiff_t   
)
delete

◆ operator-() [3/36]

constexpr auto daw::operator- ( reverse_iterator< Iterator1 > const lhs,
reverse_iterator< Iterator2 > const rhs 
) -> decltype( rhs.base( ) - lhs.base( ) )
constexpr

Definition at line 136 of file daw_reverse_iterator.h.

◆ operator-() [4/36]

constexpr UInt16 daw::operator- ( std::uint16_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2273 of file daw_uint_types.h.

◆ operator-() [5/36]

constexpr UInt16 daw::operator- ( std::uint16_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2278 of file daw_uint_types.h.

◆ operator-() [6/36]

constexpr UInt32 daw::operator- ( std::uint32_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1953 of file daw_uint_types.h.

◆ operator-() [7/36]

constexpr UInt32 daw::operator- ( std::uint32_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1948 of file daw_uint_types.h.

◆ operator-() [8/36]

constexpr UInt32 daw::operator- ( std::uint32_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1958 of file daw_uint_types.h.

◆ operator-() [9/36]

constexpr UInt64 daw::operator- ( std::uint64_t  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1533 of file daw_uint_types.h.

◆ operator-() [10/36]

constexpr UInt8 daw::operator- ( std::uint8_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2530 of file daw_uint_types.h.

◆ operator-() [11/36]

template<typename Iterator >
constexpr reverse_iterator< Iterator > daw::operator- ( typename reverse_iterator< Iterator >::difference_type  n,
reverse_iterator< Iterator > const it 
)
constexpr

Definition at line 129 of file daw_reverse_iterator.h.

◆ operator-() [12/36]

constexpr UInt16 daw::operator- ( UInt16  lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 2269 of file daw_uint_types.h.

◆ operator-() [13/36]

constexpr UInt16 daw::operator- ( UInt16  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2254 of file daw_uint_types.h.

◆ operator-() [14/36]

constexpr UInt32 daw::operator- ( UInt16  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1933 of file daw_uint_types.h.

◆ operator-() [15/36]

constexpr UInt64 daw::operator- ( UInt16  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1519 of file daw_uint_types.h.

◆ operator-() [16/36]

constexpr UInt16 daw::operator- ( UInt16  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2259 of file daw_uint_types.h.

◆ operator-() [17/36]

constexpr UInt16 daw::operator- ( UInt16  value)
constexpr

Definition at line 2414 of file daw_uint_types.h.

◆ operator-() [18/36]

constexpr UInt32 daw::operator- ( UInt32  lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 1943 of file daw_uint_types.h.

◆ operator-() [19/36]

constexpr UInt32 daw::operator- ( UInt32  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1921 of file daw_uint_types.h.

◆ operator-() [20/36]

constexpr UInt32 daw::operator- ( UInt32  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1915 of file daw_uint_types.h.

◆ operator-() [21/36]

constexpr UInt64 daw::operator- ( UInt32  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1515 of file daw_uint_types.h.

◆ operator-() [22/36]

constexpr UInt32 daw::operator- ( UInt32  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1927 of file daw_uint_types.h.

◆ operator-() [23/36]

constexpr UInt32 daw::operator- ( UInt32  value)
constexpr

Definition at line 2130 of file daw_uint_types.h.

◆ operator-() [24/36]

constexpr UInt64 daw::operator- ( UInt64  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 1528 of file daw_uint_types.h.

◆ operator-() [25/36]

constexpr UInt64 daw::operator- ( UInt64  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1505 of file daw_uint_types.h.

◆ operator-() [26/36]

constexpr UInt64 daw::operator- ( UInt64  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1500 of file daw_uint_types.h.

◆ operator-() [27/36]

constexpr UInt64 daw::operator- ( UInt64  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1495 of file daw_uint_types.h.

◆ operator-() [28/36]

constexpr UInt64 daw::operator- ( UInt64  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1510 of file daw_uint_types.h.

◆ operator-() [29/36]

constexpr UInt64 daw::operator- ( UInt64  value)
constexpr

Definition at line 1746 of file daw_uint_types.h.

◆ operator-() [30/36]

constexpr UInt8 daw::operator- ( UInt8  lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2525 of file daw_uint_types.h.

◆ operator-() [31/36]

constexpr UInt16 daw::operator- ( UInt8  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2264 of file daw_uint_types.h.

◆ operator-() [32/36]

constexpr UInt32 daw::operator- ( UInt8  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1938 of file daw_uint_types.h.

◆ operator-() [33/36]

constexpr UInt64 daw::operator- ( UInt8  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1523 of file daw_uint_types.h.

◆ operator-() [34/36]

constexpr UInt8 daw::operator- ( UInt8  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2519 of file daw_uint_types.h.

◆ operator-() [35/36]

constexpr UInt8 daw::operator- ( UInt8  value)
constexpr

Definition at line 2611 of file daw_uint_types.h.

◆ operator-() [36/36]

Definition at line 120 of file wrap_iter.h.

◆ operator--() [1/8]

constexpr UInt16 & daw::operator-- ( UInt16 value)
constexpr

Definition at line 2430 of file daw_uint_types.h.

◆ operator--() [2/8]

constexpr UInt16 daw::operator-- ( UInt16 value,
int   
)
constexpr

Definition at line 2435 of file daw_uint_types.h.

◆ operator--() [3/8]

constexpr UInt32 & daw::operator-- ( UInt32 value)
constexpr

Definition at line 2146 of file daw_uint_types.h.

◆ operator--() [4/8]

constexpr UInt32 daw::operator-- ( UInt32 value,
int   
)
constexpr

Definition at line 2151 of file daw_uint_types.h.

◆ operator--() [5/8]

constexpr UInt64 & daw::operator-- ( UInt64 value)
constexpr

Definition at line 1762 of file daw_uint_types.h.

◆ operator--() [6/8]

constexpr UInt64 daw::operator-- ( UInt64 value,
int   
)
constexpr

Definition at line 1767 of file daw_uint_types.h.

◆ operator--() [7/8]

constexpr UInt8 & daw::operator-- ( UInt8 value)
constexpr

Definition at line 2627 of file daw_uint_types.h.

◆ operator--() [8/8]

constexpr UInt8 daw::operator-- ( UInt8 value,
int   
)
constexpr

Definition at line 2632 of file daw_uint_types.h.

◆ operator-=() [1/21]

constexpr std::uint16_t & daw::operator-= ( std::uint16_t &  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2240 of file daw_uint_types.h.

◆ operator-=() [2/21]

constexpr std::uint16_t & daw::operator-= ( std::uint16_t &  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2247 of file daw_uint_types.h.

◆ operator-=() [3/21]

constexpr std::uint32_t & daw::operator-= ( std::uint32_t &  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1903 of file daw_uint_types.h.

◆ operator-=() [4/21]

constexpr std::uint32_t & daw::operator-= ( std::uint32_t &  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1897 of file daw_uint_types.h.

◆ operator-=() [5/21]

constexpr std::uint32_t & daw::operator-= ( std::uint32_t &  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1909 of file daw_uint_types.h.

◆ operator-=() [6/21]

constexpr std::uint64_t & daw::operator-= ( std::uint64_t &  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1489 of file daw_uint_types.h.

◆ operator-=() [7/21]

constexpr std::uint8_t & daw::operator-= ( std::uint8_t &  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2513 of file daw_uint_types.h.

◆ operator-=() [8/21]

constexpr UInt16 & daw::operator-= ( UInt16 lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 2235 of file daw_uint_types.h.

◆ operator-=() [9/21]

constexpr UInt16 & daw::operator-= ( UInt16 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2223 of file daw_uint_types.h.

◆ operator-=() [10/21]

constexpr UInt16 & daw::operator-= ( UInt16 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2229 of file daw_uint_types.h.

◆ operator-=() [11/21]

constexpr UInt32 & daw::operator-= ( UInt32 lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 1892 of file daw_uint_types.h.

◆ operator-=() [12/21]

constexpr UInt32 & daw::operator-= ( UInt32 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1880 of file daw_uint_types.h.

◆ operator-=() [13/21]

constexpr UInt32 & daw::operator-= ( UInt32 lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1874 of file daw_uint_types.h.

◆ operator-=() [14/21]

constexpr UInt32 & daw::operator-= ( UInt32 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1886 of file daw_uint_types.h.

◆ operator-=() [15/21]

constexpr UInt64 & daw::operator-= ( UInt64 lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 1484 of file daw_uint_types.h.

◆ operator-=() [16/21]

constexpr UInt64 & daw::operator-= ( UInt64 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1473 of file daw_uint_types.h.

◆ operator-=() [17/21]

constexpr UInt64 & daw::operator-= ( UInt64 lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1468 of file daw_uint_types.h.

◆ operator-=() [18/21]

constexpr UInt64 & daw::operator-= ( UInt64 lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1463 of file daw_uint_types.h.

◆ operator-=() [19/21]

constexpr UInt64 & daw::operator-= ( UInt64 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1478 of file daw_uint_types.h.

◆ operator-=() [20/21]

constexpr UInt8 & daw::operator-= ( UInt8 lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2508 of file daw_uint_types.h.

◆ operator-=() [21/21]

constexpr UInt8 & daw::operator-= ( UInt8 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2502 of file daw_uint_types.h.

◆ operator/() [1/30]

constexpr UInt16 daw::operator/ ( std::uint16_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2394 of file daw_uint_types.h.

◆ operator/() [2/30]

constexpr UInt16 daw::operator/ ( std::uint16_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2400 of file daw_uint_types.h.

◆ operator/() [3/30]

constexpr UInt32 daw::operator/ ( std::uint32_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2112 of file daw_uint_types.h.

◆ operator/() [4/30]

constexpr UInt32 daw::operator/ ( std::uint32_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 2107 of file daw_uint_types.h.

◆ operator/() [5/30]

constexpr UInt32 daw::operator/ ( std::uint32_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2117 of file daw_uint_types.h.

◆ operator/() [6/30]

constexpr UInt64 daw::operator/ ( std::uint64_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1728 of file daw_uint_types.h.

◆ operator/() [7/30]

constexpr UInt64 daw::operator/ ( std::uint64_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1723 of file daw_uint_types.h.

◆ operator/() [8/30]

constexpr UInt64 daw::operator/ ( std::uint64_t  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1718 of file daw_uint_types.h.

◆ operator/() [9/30]

constexpr UInt64 daw::operator/ ( std::uint64_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1733 of file daw_uint_types.h.

◆ operator/() [10/30]

constexpr UInt8 daw::operator/ ( std::uint8_t  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 2597 of file daw_uint_types.h.

◆ operator/() [11/30]

constexpr UInt16 daw::operator/ ( UInt16  lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 2389 of file daw_uint_types.h.

◆ operator/() [12/30]

constexpr UInt16 daw::operator/ ( UInt16  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2374 of file daw_uint_types.h.

◆ operator/() [13/30]

constexpr UInt32 daw::operator/ ( UInt16  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 2092 of file daw_uint_types.h.

◆ operator/() [14/30]

constexpr UInt64 daw::operator/ ( UInt16  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1703 of file daw_uint_types.h.

◆ operator/() [15/30]

constexpr UInt16 daw::operator/ ( UInt16  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2379 of file daw_uint_types.h.

◆ operator/() [16/30]

constexpr UInt32 daw::operator/ ( UInt32  lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 2102 of file daw_uint_types.h.

◆ operator/() [17/30]

constexpr UInt32 daw::operator/ ( UInt32  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2082 of file daw_uint_types.h.

◆ operator/() [18/30]

constexpr UInt32 daw::operator/ ( UInt32  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 2077 of file daw_uint_types.h.

◆ operator/() [19/30]

constexpr UInt64 daw::operator/ ( UInt32  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1698 of file daw_uint_types.h.

◆ operator/() [20/30]

constexpr UInt32 daw::operator/ ( UInt32  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2087 of file daw_uint_types.h.

◆ operator/() [21/30]

constexpr UInt64 daw::operator/ ( UInt64  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 1713 of file daw_uint_types.h.

◆ operator/() [22/30]

constexpr UInt64 daw::operator/ ( UInt64  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1686 of file daw_uint_types.h.

◆ operator/() [23/30]

constexpr UInt64 daw::operator/ ( UInt64  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1680 of file daw_uint_types.h.

◆ operator/() [24/30]

constexpr UInt64 daw::operator/ ( UInt64  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1675 of file daw_uint_types.h.

◆ operator/() [25/30]

constexpr UInt64 daw::operator/ ( UInt64  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1692 of file daw_uint_types.h.

◆ operator/() [26/30]

constexpr UInt8 daw::operator/ ( UInt8  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 2592 of file daw_uint_types.h.

◆ operator/() [27/30]

constexpr UInt16 daw::operator/ ( UInt8  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2384 of file daw_uint_types.h.

◆ operator/() [28/30]

constexpr UInt32 daw::operator/ ( UInt8  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 2097 of file daw_uint_types.h.

◆ operator/() [29/30]

constexpr UInt64 daw::operator/ ( UInt8  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1708 of file daw_uint_types.h.

◆ operator/() [30/30]

constexpr UInt8 daw::operator/ ( UInt8  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2586 of file daw_uint_types.h.

◆ operator/=() [1/22]

constexpr std::uint16_t & daw::operator/= ( std::uint16_t &  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2360 of file daw_uint_types.h.

◆ operator/=() [2/22]

constexpr std::uint16_t & daw::operator/= ( std::uint16_t &  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2367 of file daw_uint_types.h.

◆ operator/=() [3/22]

constexpr std::uint32_t & daw::operator/= ( std::uint32_t &  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 2071 of file daw_uint_types.h.

◆ operator/=() [4/22]

constexpr std::uint64_t & daw::operator/= ( std::uint64_t &  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1663 of file daw_uint_types.h.

◆ operator/=() [5/22]

constexpr std::uint64_t & daw::operator/= ( std::uint64_t &  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1657 of file daw_uint_types.h.

◆ operator/=() [6/22]

constexpr std::uint64_t & daw::operator/= ( std::uint64_t &  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1651 of file daw_uint_types.h.

◆ operator/=() [7/22]

constexpr std::uint64_t & daw::operator/= ( std::uint64_t &  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1669 of file daw_uint_types.h.

◆ operator/=() [8/22]

constexpr std::uint8_t & daw::operator/= ( std::uint8_t &  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 2580 of file daw_uint_types.h.

◆ operator/=() [9/22]

constexpr UInt16 & daw::operator/= ( UInt16 lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 2355 of file daw_uint_types.h.

◆ operator/=() [10/22]

constexpr UInt16 & daw::operator/= ( UInt16 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2343 of file daw_uint_types.h.

◆ operator/=() [11/22]

constexpr UInt16 & daw::operator/= ( UInt16 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2349 of file daw_uint_types.h.

◆ operator/=() [12/22]

constexpr UInt32 & daw::operator/= ( UInt32 lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 2066 of file daw_uint_types.h.

◆ operator/=() [13/22]

constexpr UInt32 & daw::operator/= ( UInt32 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 2054 of file daw_uint_types.h.

◆ operator/=() [14/22]

constexpr UInt32 & daw::operator/= ( UInt32 lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 2048 of file daw_uint_types.h.

◆ operator/=() [15/22]

constexpr UInt32 & daw::operator/= ( UInt32 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2060 of file daw_uint_types.h.

◆ operator/=() [16/22]

constexpr UInt64 & daw::operator/= ( UInt64 lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 1646 of file daw_uint_types.h.

◆ operator/=() [17/22]

constexpr UInt64 & daw::operator/= ( UInt64 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1634 of file daw_uint_types.h.

◆ operator/=() [18/22]

constexpr UInt64 & daw::operator/= ( UInt64 lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1628 of file daw_uint_types.h.

◆ operator/=() [19/22]

constexpr UInt64 & daw::operator/= ( UInt64 lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 1622 of file daw_uint_types.h.

◆ operator/=() [20/22]

constexpr UInt64 & daw::operator/= ( UInt64 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1640 of file daw_uint_types.h.

◆ operator/=() [21/22]

constexpr UInt8 & daw::operator/= ( UInt8 lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 2575 of file daw_uint_types.h.

◆ operator/=() [22/22]

constexpr UInt8 & daw::operator/= ( UInt8 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2569 of file daw_uint_types.h.

◆ operator<() [1/41]

template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool daw::operator< ( basic_bounded_string< CharT, CapacityL > const lhs,
basic_bounded_string< CharT, CapacityR > const rhs 
)
constexprnoexcept

Definition at line 808 of file daw_bounded_string.h.

◆ operator<() [2/41]

template<typename CharT , size_t Capacity, size_t N>
constexpr bool daw::operator< ( CharT const (&)  lhs[N],
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1209 of file daw_bounded_string.h.

◆ operator<() [3/41]

constexpr bool daw::operator< ( copiable_unique_ptr< T1, D1 > const lhs,
copiable_unique_ptr< T2, D2 > const rhs 
)
constexprnoexcept

Definition at line 181 of file daw_copiable_unique_ptr.h.

◆ operator<() [4/41]

constexpr bool daw::operator< ( copiable_unique_ptr< T1, D1 > const lhs,
std::nullptr_t   
)
constexprnoexcept

Definition at line 190 of file daw_copiable_unique_ptr.h.

◆ operator<() [5/41]

template<typename CharT , size_t Capacity, size_t N>
constexpr bool daw::operator< ( daw::basic_bounded_string< CharT, Capacity > const lhs,
CharT const (&)  rhs[N] 
)
constexprnoexcept

Definition at line 1159 of file daw_bounded_string.h.

◆ operator<() [6/41]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator< ( daw::basic_bounded_string< CharT, Capacity > const lhs,
daw::sv1::basic_string_view< CharT >  rhs 
)
constexprnoexcept

Definition at line 858 of file daw_bounded_string.h.

◆ operator<() [7/41]

template<typename CharT , size_t Capacity>
bool daw::operator< ( daw::basic_bounded_string< CharT, Capacity > const lhs,
std::basic_string< CharT > const rhs 
)
noexcept

Definition at line 957 of file daw_bounded_string.h.

◆ operator<() [8/41]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator< ( daw::basic_bounded_string< CharT, Capacity > const lhs,
typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  rhs 
)
constexprnoexcept

Definition at line 1055 of file daw_bounded_string.h.

◆ operator<() [9/41]

template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool daw::operator< ( daw::not_null< Lhs > const lhs,
daw::not_null< Rhs > const rhs 
)
constexprnoexcept

Definition at line 304 of file daw_not_null.h.

◆ operator<() [10/41]

template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool daw::operator< ( daw::not_null< Pointer > const lhs,
Pointer const rhs 
)
constexprnoexcept

Definition at line 311 of file daw_not_null.h.

◆ operator<() [11/41]

template<typename T >
bool daw::operator< ( daw::optional_poly< T > const lhs,
daw::optional_poly< T > const rhs 
)

Definition at line 206 of file daw_optional_poly.h.

◆ operator<() [12/41]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator< ( daw::sv1::basic_string_view< CharT > const lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 908 of file daw_bounded_string.h.

◆ operator<() [13/41]

Definition at line 280 of file daw_hash_table.h.

◆ operator<() [14/41]

template<typename T , typename U >
bool daw::operator< ( heap_value< T > const lhs,
heap_value< U > const rhs 
)

Definition at line 149 of file deprecated/daw_heap_value.h.

◆ operator<() [15/41]

template<typename T >
constexpr bool daw::operator< ( indexed_iterator< T > const lhs,
indexed_iterator< T > const rhs 
)
constexprnoexcept

Definition at line 316 of file daw_indexed_iterator.h.

◆ operator<() [16/41]

template<typename T , typename U >
constexpr bool daw::operator< ( natural_t< T > const lhs,
natural_t< U > const rhs 
)
constexprnoexcept

Definition at line 193 of file daw_natural.h.

◆ operator<() [17/41]

constexpr bool daw::operator< ( node_id_t const lhs,
node_id_t const rhs 
)
constexprnoexcept

Definition at line 82 of file daw_bounded_graph.h.

◆ operator<() [18/41]

template<typename T >
constexpr bool daw::operator< ( optional< T > const ,
std::nullopt_t   
)
constexprnoexcept

Definition at line 339 of file daw_optional.h.

◆ operator<() [19/41]

template<typename T , typename U >
constexpr bool daw::operator< ( optional< T > const lhs,
optional< U > const rhs 
)
constexpr

Definition at line 275 of file daw_optional.h.

◆ operator<() [20/41]

template<typename T , typename U >
constexpr bool daw::operator< ( optional< T > const opt,
U const value 
)
constexpr

Definition at line 414 of file daw_optional.h.

◆ operator<() [21/41]

template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool daw::operator< ( Pointer const lhs,
daw::not_null< Pointer > const rhs 
)
constexprnoexcept

Definition at line 317 of file daw_not_null.h.

◆ operator<() [22/41]

template<typename T >
bool daw::operator< ( Reference< T > const lhs,
Reference< T > const rhs 
)

Definition at line 51 of file daw_reference.h.

◆ operator<() [23/41]

Definition at line 156 of file daw_reverse_iterator.h.

◆ operator<() [24/41]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator< ( std::basic_string< CharT > const lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1003 of file daw_bounded_string.h.

◆ operator<() [25/41]

template<typename T >
constexpr bool daw::operator< ( std::nullopt_t  ,
optional< T > const opt 
)
constexprnoexcept

Definition at line 344 of file daw_optional.h.

◆ operator<() [26/41]

constexpr bool daw::operator< ( std::nullptr_t  ,
copiable_unique_ptr< T1, D1 > const rhs 
)
constexprnoexcept

Definition at line 198 of file daw_copiable_unique_ptr.h.

◆ operator<() [27/41]

constexpr bool daw::operator< ( std::uint16_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1341 of file daw_uint_types.h.

◆ operator<() [28/41]

constexpr bool daw::operator< ( std::uint32_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 922 of file daw_uint_types.h.

◆ operator<() [29/41]

constexpr bool daw::operator< ( std::uint64_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 512 of file daw_uint_types.h.

◆ operator<() [30/41]

constexpr bool daw::operator< ( std::uint64_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 507 of file daw_uint_types.h.

◆ operator<() [31/41]

constexpr bool daw::operator< ( std::uint64_t  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 502 of file daw_uint_types.h.

◆ operator<() [32/41]

constexpr bool daw::operator< ( std::uint64_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 517 of file daw_uint_types.h.

◆ operator<() [33/41]

constexpr bool daw::operator< ( std::uint8_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2786 of file daw_uint_types.h.

◆ operator<() [34/41]

template<typename T , typename U >
constexpr bool daw::operator< ( T const value,
optional< U > const opt 
)
constexpr

Definition at line 422 of file daw_optional.h.

◆ operator<() [35/41]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator< ( typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1109 of file daw_bounded_string.h.

◆ operator<() [36/41]

constexpr bool daw::operator< ( UInt16  lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 1335 of file daw_uint_types.h.

◆ operator<() [37/41]

constexpr bool daw::operator< ( UInt32  lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 916 of file daw_uint_types.h.

◆ operator<() [38/41]

constexpr bool daw::operator< ( UInt64  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 497 of file daw_uint_types.h.

◆ operator<() [39/41]

constexpr bool daw::operator< ( UInt8  lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2780 of file daw_uint_types.h.

◆ operator<() [40/41]

template<typename T , typename D0 , typename D1 = D0>
constexpr bool daw::operator< ( unique_ptr< T, D0 > const lhs,
unique_ptr< T, D1 > const rhs 
)
constexprnoexcept

Definition at line 443 of file daw_unique_ptr.h.

◆ operator<() [41/41]

template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_less< T, U >, std::nullptr_t > = nullptr>
constexpr bool daw::operator< ( value_ptr< T > const lhs,
value_ptr< U > const rhs 
)
constexprnoexcept

Definition at line 281 of file daw_value_ptr.h.

◆ operator<<() [1/28]

template<typename OStream , typename CharT , size_t Capacity, std::enable_if_t< daw::traits::is_ostream_like_v< OStream, CharT >, std::nullptr_t > = nullptr>
OStream & daw::operator<< ( OStream os,
daw::basic_bounded_string< CharT, Capacity > const str 
)

Definition at line 1355 of file daw_bounded_string.h.

◆ operator<<() [2/28]

template<typename OStream , typename T , std::enable_if_t< daw::traits::is_ostream_like_lite_v< OStream >, std::nullptr_t > = nullptr>
OStream & daw::operator<< ( OStream os,
Reference< T > const ref 
)

Definition at line 95 of file daw_reference.h.

◆ operator<<() [3/28]

template<size_t BitWidth>
std::ostream & daw::operator<< ( std::ostream &  os,
static_bitset< BitWidth > const bs 
)
inline

Definition at line 536 of file daw_static_bitset.h.

◆ operator<<() [4/28]

std::ostream & daw::operator<< ( std::ostream &  os,
UInt16  rhs 
)

Definition at line 22 of file daw_uint_buffer_ios.h.

◆ operator<<() [5/28]

std::ostream & daw::operator<< ( std::ostream &  os,
UInt32  rhs 
)

Definition at line 27 of file daw_uint_buffer_ios.h.

◆ operator<<() [6/28]

std::ostream & daw::operator<< ( std::ostream &  os,
UInt64  rhs 
)

Definition at line 32 of file daw_uint_buffer_ios.h.

◆ operator<<() [7/28]

std::ostream & daw::operator<< ( std::ostream &  os,
UInt8  rhs 
)

Definition at line 17 of file daw_uint_buffer_ios.h.

◆ operator<<() [8/28]

constexpr std::uint16_t daw::operator<< ( std::uint16_t  b,
UInt16  shift 
)
constexprnoexcept

Definition at line 1158 of file daw_uint_types.h.

◆ operator<<() [9/28]

constexpr std::uint32_t daw::operator<< ( std::uint32_t  b,
UInt32  shift 
)
constexprnoexcept

Definition at line 770 of file daw_uint_types.h.

◆ operator<<() [10/28]

constexpr std::uint64_t daw::operator<< ( std::uint64_t  b,
UInt16  shift 
)
constexprnoexcept

Definition at line 172 of file daw_uint_types.h.

◆ operator<<() [11/28]

constexpr std::uint64_t daw::operator<< ( std::uint64_t  b,
UInt32  shift 
)
constexprnoexcept

Definition at line 167 of file daw_uint_types.h.

◆ operator<<() [12/28]

constexpr std::uint64_t daw::operator<< ( std::uint64_t  b,
UInt64  shift 
)
constexprnoexcept

Definition at line 162 of file daw_uint_types.h.

◆ operator<<() [13/28]

constexpr std::uint64_t daw::operator<< ( std::uint64_t  b,
UInt8  shift 
)
constexprnoexcept

Definition at line 177 of file daw_uint_types.h.

◆ operator<<() [14/28]

constexpr std::uint8_t daw::operator<< ( std::uint8_t  b,
UInt8  shift 
)
constexprnoexcept

Definition at line 2684 of file daw_uint_types.h.

◆ operator<<() [15/28]

constexpr UInt16 daw::operator<< ( UInt16  b,
std::uint16_t  shift 
)
constexprnoexcept

Definition at line 1139 of file daw_uint_types.h.

◆ operator<<() [16/28]

constexpr UInt16 daw::operator<< ( UInt16  b,
UInt16  shift 
)
constexprnoexcept

Definition at line 1146 of file daw_uint_types.h.

◆ operator<<() [17/28]

constexpr UInt16 daw::operator<< ( UInt16  b,
UInt8  shift 
)
constexprnoexcept

Definition at line 1152 of file daw_uint_types.h.

◆ operator<<() [18/28]

constexpr UInt32 daw::operator<< ( UInt32  b,
std::uint32_t  shift 
)
constexprnoexcept

Definition at line 745 of file daw_uint_types.h.

◆ operator<<() [19/28]

constexpr UInt32 daw::operator<< ( UInt32  b,
UInt16  shift 
)
constexprnoexcept

Definition at line 758 of file daw_uint_types.h.

◆ operator<<() [20/28]

constexpr UInt32 daw::operator<< ( UInt32  b,
UInt32  shift 
)
constexprnoexcept

Definition at line 752 of file daw_uint_types.h.

◆ operator<<() [21/28]

constexpr UInt32 daw::operator<< ( UInt32  b,
UInt8  shift 
)
constexprnoexcept

Definition at line 764 of file daw_uint_types.h.

◆ operator<<() [22/28]

constexpr UInt64 daw::operator<< ( UInt64  b,
std::uint64_t  shift 
)
constexprnoexcept

Definition at line 132 of file daw_uint_types.h.

◆ operator<<() [23/28]

constexpr UInt64 daw::operator<< ( UInt64  b,
UInt16  shift 
)
constexprnoexcept

Definition at line 150 of file daw_uint_types.h.

◆ operator<<() [24/28]

constexpr UInt64 daw::operator<< ( UInt64  b,
UInt32  shift 
)
constexprnoexcept

Definition at line 144 of file daw_uint_types.h.

◆ operator<<() [25/28]

constexpr UInt64 daw::operator<< ( UInt64  b,
UInt64  shift 
)
constexprnoexcept

Definition at line 138 of file daw_uint_types.h.

◆ operator<<() [26/28]

constexpr UInt64 daw::operator<< ( UInt64  b,
UInt8  shift 
)
constexprnoexcept

Definition at line 156 of file daw_uint_types.h.

◆ operator<<() [27/28]

constexpr UInt8 daw::operator<< ( UInt8  b,
std::uint8_t  shift 
)
constexprnoexcept

Definition at line 2671 of file daw_uint_types.h.

◆ operator<<() [28/28]

constexpr UInt8 daw::operator<< ( UInt8  b,
UInt8  shift 
)
constexprnoexcept

Definition at line 2678 of file daw_uint_types.h.

◆ operator<<=() [1/14]

constexpr UInt16 & daw::operator<<= ( UInt16 b,
std::uint16_t  shift 
)
constexprnoexcept

Definition at line 1095 of file daw_uint_types.h.

◆ operator<<=() [2/14]

constexpr UInt16 & daw::operator<<= ( UInt16 b,
UInt16  shift 
)
constexprnoexcept

Definition at line 1103 of file daw_uint_types.h.

◆ operator<<=() [3/14]

constexpr UInt16 & daw::operator<<= ( UInt16 b,
UInt8  shift 
)
constexprnoexcept

Definition at line 1110 of file daw_uint_types.h.

◆ operator<<=() [4/14]

constexpr UInt32 & daw::operator<<= ( UInt32 b,
std::uint32_t  shift 
)
constexprnoexcept

Definition at line 687 of file daw_uint_types.h.

◆ operator<<=() [5/14]

constexpr UInt32 & daw::operator<<= ( UInt32 b,
UInt16  shift 
)
constexprnoexcept

Definition at line 702 of file daw_uint_types.h.

◆ operator<<=() [6/14]

constexpr UInt32 & daw::operator<<= ( UInt32 b,
UInt32  shift 
)
constexprnoexcept

Definition at line 695 of file daw_uint_types.h.

◆ operator<<=() [7/14]

constexpr UInt32 & daw::operator<<= ( UInt32 b,
UInt8  shift 
)
constexprnoexcept

Definition at line 709 of file daw_uint_types.h.

◆ operator<<=() [8/14]

constexpr UInt64 & daw::operator<<= ( UInt64 b,
std::uint64_t  shift 
)
constexprnoexcept

Definition at line 62 of file daw_uint_types.h.

◆ operator<<=() [9/14]

constexpr UInt64 & daw::operator<<= ( UInt64 b,
UInt16  shift 
)
constexprnoexcept

Definition at line 83 of file daw_uint_types.h.

◆ operator<<=() [10/14]

constexpr UInt64 & daw::operator<<= ( UInt64 b,
UInt32  shift 
)
constexprnoexcept

Definition at line 76 of file daw_uint_types.h.

◆ operator<<=() [11/14]

constexpr UInt64 & daw::operator<<= ( UInt64 b,
UInt64  shift 
)
constexprnoexcept

Definition at line 69 of file daw_uint_types.h.

◆ operator<<=() [12/14]

constexpr UInt64 & daw::operator<<= ( UInt64 b,
UInt8  shift 
)
constexprnoexcept

Definition at line 90 of file daw_uint_types.h.

◆ operator<<=() [13/14]

constexpr UInt8 & daw::operator<<= ( UInt8 b,
std::uint8_t  shift 
)
constexprnoexcept

Definition at line 2641 of file daw_uint_types.h.

◆ operator<<=() [14/14]

constexpr UInt8 & daw::operator<<= ( UInt8 b,
UInt8  shift 
)
constexprnoexcept

Definition at line 2649 of file daw_uint_types.h.

◆ operator<=() [1/43]

template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool daw::operator<= ( basic_bounded_string< CharT, CapacityL > const lhs,
basic_bounded_string< CharT, CapacityR > const rhs 
)
constexprnoexcept

Definition at line 816 of file daw_bounded_string.h.

◆ operator<=() [2/43]

template<typename CharT , size_t Capacity, size_t N>
constexpr bool daw::operator<= ( CharT const (&)  lhs[N],
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1216 of file daw_bounded_string.h.

◆ operator<=() [3/43]

constexpr bool daw::operator<= ( copiable_unique_ptr< T1, D1 > const lhs,
copiable_unique_ptr< T2, D2 > const rhs 
)
constexprnoexcept

Definition at line 206 of file daw_copiable_unique_ptr.h.

◆ operator<=() [4/43]

constexpr bool daw::operator<= ( copiable_unique_ptr< T1, D1 > const lhs,
std::nullptr_t   
)
constexprnoexcept

Definition at line 212 of file daw_copiable_unique_ptr.h.

◆ operator<=() [5/43]

template<typename CharT , size_t Capacity, size_t N>
constexpr bool daw::operator<= ( daw::basic_bounded_string< CharT, Capacity > const lhs,
CharT const (&)  rhs[N] 
)
constexprnoexcept

Definition at line 1167 of file daw_bounded_string.h.

◆ operator<=() [6/43]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator<= ( daw::basic_bounded_string< CharT, Capacity > const lhs,
daw::sv1::basic_string_view< CharT >  rhs 
)
constexprnoexcept

Definition at line 866 of file daw_bounded_string.h.

◆ operator<=() [7/43]

template<typename CharT , size_t Capacity>
bool daw::operator<= ( daw::basic_bounded_string< CharT, Capacity > const lhs,
std::basic_string< CharT > const rhs 
)
noexcept

Definition at line 964 of file daw_bounded_string.h.

◆ operator<=() [8/43]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator<= ( daw::basic_bounded_string< CharT, Capacity > const lhs,
typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  rhs 
)
constexprnoexcept

Definition at line 1064 of file daw_bounded_string.h.

◆ operator<=() [9/43]

template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool daw::operator<= ( daw::not_null< Lhs > const lhs,
daw::not_null< Rhs > const rhs 
)
constexprnoexcept

Definition at line 323 of file daw_not_null.h.

◆ operator<=() [10/43]

template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool daw::operator<= ( daw::not_null< Pointer > const lhs,
Pointer const rhs 
)
constexprnoexcept

Definition at line 330 of file daw_not_null.h.

◆ operator<=() [11/43]

template<typename T >
bool daw::operator<= ( daw::optional_poly< T > const lhs,
daw::optional_poly< T > const rhs 
)

Definition at line 218 of file daw_optional_poly.h.

◆ operator<=() [12/43]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator<= ( daw::sv1::basic_string_view< CharT > const lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 916 of file daw_bounded_string.h.

◆ operator<=() [13/43]

Definition at line 286 of file daw_hash_table.h.

◆ operator<=() [14/43]

template<typename T , typename U >
bool daw::operator<= ( heap_value< T > const lhs,
heap_value< U > const rhs 
)

Definition at line 139 of file deprecated/daw_heap_value.h.

◆ operator<=() [15/43]

template<typename T >
constexpr bool daw::operator<= ( indexed_iterator< T > const lhs,
indexed_iterator< T > const rhs 
)
constexprnoexcept

Definition at line 328 of file daw_indexed_iterator.h.

◆ operator<=() [16/43]

template<typename T , typename U >
constexpr bool daw::operator<= ( natural_t< T > const lhs,
natural_t< U > const rhs 
)
constexprnoexcept

Definition at line 199 of file daw_natural.h.

◆ operator<=() [17/43]

template<typename T , typename U >
constexpr bool daw::operator<= ( optional< T > const lhs,
optional< U > const rhs 
)
constexpr

Definition at line 286 of file daw_optional.h.

◆ operator<=() [18/43]

template<typename T >
constexpr bool daw::operator<= ( optional< T > const opt,
std::nullopt_t   
)
constexprnoexcept

Definition at line 349 of file daw_optional.h.

◆ operator<=() [19/43]

template<typename T , typename U >
constexpr bool daw::operator<= ( optional< T > const opt,
U const value 
)
constexpr

Definition at line 430 of file daw_optional.h.

◆ operator<=() [20/43]

template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool daw::operator<= ( Pointer const lhs,
daw::not_null< Pointer > const rhs 
)
constexprnoexcept

Definition at line 336 of file daw_not_null.h.

◆ operator<=() [21/43]

template<typename T >
bool daw::operator<= ( Reference< T > const lhs,
Reference< T > const rhs 
)

Definition at line 56 of file daw_reference.h.

◆ operator<=() [22/43]

Definition at line 162 of file daw_reverse_iterator.h.

◆ operator<=() [23/43]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator<= ( std::basic_string< CharT > const lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1011 of file daw_bounded_string.h.

◆ operator<=() [24/43]

template<typename T >
constexpr bool daw::operator<= ( std::nullopt_t  ,
optional< T > const  
)
constexprnoexcept

Definition at line 354 of file daw_optional.h.

◆ operator<=() [25/43]

constexpr bool daw::operator<= ( std::nullptr_t  ,
copiable_unique_ptr< T2, D2 > const rhs 
)
constexprnoexcept

Definition at line 219 of file daw_copiable_unique_ptr.h.

◆ operator<=() [26/43]

constexpr bool daw::operator<= ( std::uint16_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1353 of file daw_uint_types.h.

◆ operator<=() [27/43]

constexpr bool daw::operator<= ( std::uint32_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 934 of file daw_uint_types.h.

◆ operator<=() [28/43]

constexpr bool daw::operator<= ( std::uint64_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 552 of file daw_uint_types.h.

◆ operator<=() [29/43]

constexpr bool daw::operator<= ( std::uint64_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 547 of file daw_uint_types.h.

◆ operator<=() [30/43]

constexpr bool daw::operator<= ( std::uint64_t  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 542 of file daw_uint_types.h.

◆ operator<=() [31/43]

constexpr bool daw::operator<= ( std::uint64_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 557 of file daw_uint_types.h.

◆ operator<=() [32/43]

constexpr bool daw::operator<= ( std::uint8_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2798 of file daw_uint_types.h.

◆ operator<=() [33/43]

template<typename T , typename U >
constexpr bool daw::operator<= ( T const value,
optional< U > const opt 
)
constexpr

Definition at line 438 of file daw_optional.h.

◆ operator<=() [34/43]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator<= ( typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1117 of file daw_bounded_string.h.

◆ operator<=() [35/43]

constexpr bool daw::operator<= ( UInt16  lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 1347 of file daw_uint_types.h.

◆ operator<=() [36/43]

constexpr bool daw::operator<= ( UInt16  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 532 of file daw_uint_types.h.

◆ operator<=() [37/43]

constexpr bool daw::operator<= ( UInt32  lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 928 of file daw_uint_types.h.

◆ operator<=() [38/43]

constexpr bool daw::operator<= ( UInt32  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 527 of file daw_uint_types.h.

◆ operator<=() [39/43]

constexpr bool daw::operator<= ( UInt64  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 522 of file daw_uint_types.h.

◆ operator<=() [40/43]

constexpr bool daw::operator<= ( UInt8  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 537 of file daw_uint_types.h.

◆ operator<=() [41/43]

constexpr bool daw::operator<= ( UInt8  lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2792 of file daw_uint_types.h.

◆ operator<=() [42/43]

template<typename T , typename D0 , typename D1 = D0>
constexpr bool daw::operator<= ( unique_ptr< T, D0 > const lhs,
unique_ptr< T, D1 > const rhs 
)
constexprnoexcept

Definition at line 449 of file daw_unique_ptr.h.

◆ operator<=() [43/43]

template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_less_equal< T, U >, std::nullptr_t > = nullptr>
constexpr bool daw::operator<= ( value_ptr< T > const lhs,
value_ptr< U > const rhs 
)
constexprnoexcept

Definition at line 290 of file daw_value_ptr.h.

◆ operator==() [1/57]

template<typename T , typename U , size_t N>
constexpr bool daw::operator== ( array< T, N > const lhs,
array< U, N > const rhs 
)
constexpr

Definition at line 102 of file daw_bounded_array.h.

◆ operator==() [2/57]

template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool daw::operator== ( basic_bounded_string< CharT, CapacityL > const lhs,
basic_bounded_string< CharT, CapacityR > const rhs 
)
constexprnoexcept

Definition at line 793 of file daw_bounded_string.h.

◆ operator==() [3/57]

Definition at line 248 of file daw_bounded_hash_map.h.

◆ operator==() [4/57]

Definition at line 262 of file daw_bounded_hash_map.h.

◆ operator==() [5/57]

template<typename Key >
constexpr bool daw::operator== ( bounded_hash_set_iterator< Key > const lhs,
bounded_hash_set_iterator< Key > const rhs 
)
constexprnoexcept

Definition at line 226 of file daw_bounded_hash_set.h.

◆ operator==() [6/57]

Definition at line 240 of file daw_bounded_hash_set.h.

◆ operator==() [7/57]

template<typename CharT , size_t Capacity, size_t N>
constexpr bool daw::operator== ( CharT const (&)  lhs[N],
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1194 of file daw_bounded_string.h.

◆ operator==() [8/57]

Definition at line 269 of file daw_bounded_hash_map.h.

◆ operator==() [9/57]

Definition at line 255 of file daw_bounded_hash_map.h.

◆ operator==() [10/57]

Definition at line 247 of file daw_bounded_hash_set.h.

◆ operator==() [11/57]

Definition at line 233 of file daw_bounded_hash_set.h.

◆ operator==() [12/57]

constexpr bool daw::operator== ( copiable_unique_ptr< T1, D1 > const lhs,
copiable_unique_ptr< T2, D2 > const rhs 
)
constexprnoexcept

Definition at line 142 of file daw_copiable_unique_ptr.h.

◆ operator==() [13/57]

constexpr bool daw::operator== ( copiable_unique_ptr< T1, D1 > const lhs,
std::nullptr_t   
)
constexprnoexcept

Definition at line 148 of file daw_copiable_unique_ptr.h.

◆ operator==() [14/57]

template<typename CharT , size_t Capacity, size_t N>
constexpr bool daw::operator== ( daw::basic_bounded_string< CharT, Capacity > const lhs,
CharT const (&)  rhs[N] 
)
constexprnoexcept

Definition at line 1144 of file daw_bounded_string.h.

◆ operator==() [15/57]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator== ( daw::basic_bounded_string< CharT, Capacity > const lhs,
daw::sv1::basic_string_view< CharT >  rhs 
)
constexprnoexcept

Definition at line 843 of file daw_bounded_string.h.

◆ operator==() [16/57]

template<typename CharT , size_t Capacity>
bool daw::operator== ( daw::basic_bounded_string< CharT, Capacity > const lhs,
std::basic_string< CharT > const rhs 
)
noexcept

Definition at line 943 of file daw_bounded_string.h.

◆ operator==() [17/57]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator== ( daw::basic_bounded_string< CharT, Capacity > const lhs,
typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  rhs 
)
constexprnoexcept

Definition at line 1038 of file daw_bounded_string.h.

◆ operator==() [18/57]

template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool daw::operator== ( daw::not_null< Lhs > const lhs,
daw::not_null< Rhs > const rhs 
)
constexprnoexcept

Definition at line 267 of file daw_not_null.h.

◆ operator==() [19/57]

template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool daw::operator== ( daw::not_null< Pointer > const lhs,
Pointer const rhs 
)
constexprnoexcept

Definition at line 274 of file daw_not_null.h.

◆ operator==() [20/57]

template<typename T >
bool daw::operator== ( daw::optional_poly< T > const lhs,
daw::optional_poly< T > const rhs 
)

Definition at line 182 of file daw_optional_poly.h.

◆ operator==() [21/57]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator== ( daw::sv1::basic_string_view< CharT > const lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 893 of file daw_bounded_string.h.

◆ operator==() [22/57]

Definition at line 256 of file daw_hash_table.h.

◆ operator==() [23/57]

template<typename T , typename U >
bool daw::operator== ( heap_value< T > const lhs,
heap_value< U > const rhs 
)

Definition at line 124 of file deprecated/daw_heap_value.h.

◆ operator==() [24/57]

template<typename T , typename U , std::enable_if_t< not std::is_convertible_v< T, U >, std::nullptr_t > = nullptr>
constexpr bool daw::operator== ( indexed_iterator< T > const ,
indexed_iterator< U > const  
)
constexprnoexcept

Definition at line 295 of file daw_indexed_iterator.h.

◆ operator==() [25/57]

template<typename T >
constexpr bool daw::operator== ( indexed_iterator< T > const lhs,
indexed_iterator< T > const rhs 
)
constexprnoexcept

Definition at line 286 of file daw_indexed_iterator.h.

◆ operator==() [26/57]

template<typename T , typename U >
constexpr bool daw::operator== ( natural_t< T > const lhs,
natural_t< U > const rhs 
)
constexprnoexcept

Definition at line 181 of file daw_natural.h.

◆ operator==() [27/57]

constexpr bool daw::operator== ( node_id_t const lhs,
node_id_t const rhs 
)
constexprnoexcept

Definition at line 72 of file daw_bounded_graph.h.

◆ operator==() [28/57]

template<typename T , typename U >
constexpr bool daw::operator== ( optional< T > const lhs,
optional< U > const rhs 
)
constexpr

Definition at line 253 of file daw_optional.h.

◆ operator==() [29/57]

template<typename T >
constexpr bool daw::operator== ( optional< T > const opt,
std::nullopt_t   
)
constexprnoexcept

Definition at line 319 of file daw_optional.h.

◆ operator==() [30/57]

template<typename T , typename U >
constexpr bool daw::operator== ( optional< T > const opt,
U const value 
)
constexpr

Definition at line 382 of file daw_optional.h.

◆ operator==() [31/57]

template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool daw::operator== ( Pointer const lhs,
daw::not_null< Pointer > const rhs 
)
constexprnoexcept

Definition at line 280 of file daw_not_null.h.

◆ operator==() [32/57]

template<typename T >
bool daw::operator== ( Reference< T > const lhs,
Reference< T > const rhs 
)

Definition at line 41 of file daw_reference.h.

◆ operator==() [33/57]

template<typename CharT >
constexpr bool daw::operator== ( repeat_n_char_iterator< CharT > const lhs,
repeat_n_char_iterator< CharT > const rhs 
)
constexprnoexcept

Definition at line 111 of file daw_repeat_n_char_iterator.h.

◆ operator==() [34/57]

Definition at line 144 of file daw_reverse_iterator.h.

◆ operator==() [35/57]

template<typename Iterator >
constexpr bool daw::operator== ( splitter_range_t< Iterator > const lhs,
splitter_range_t< Iterator > const rhs 
)
constexprnoexcept

Definition at line 81 of file daw_split_iterator.h.

◆ operator==() [36/57]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator== ( std::basic_string< CharT > const lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 988 of file daw_bounded_string.h.

◆ operator==() [37/57]

template<typename T >
constexpr bool daw::operator== ( std::nullopt_t  ,
optional< T > const opt 
)
constexprnoexcept

Definition at line 324 of file daw_optional.h.

◆ operator==() [38/57]

constexpr bool daw::operator== ( std::nullptr_t  ,
copiable_unique_ptr< T1, D1 > const rhs 
)
constexprnoexcept

Definition at line 154 of file daw_copiable_unique_ptr.h.

◆ operator==() [39/57]

constexpr bool daw::operator== ( std::uint16_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1293 of file daw_uint_types.h.

◆ operator==() [40/57]

constexpr bool daw::operator== ( std::uint32_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 982 of file daw_uint_types.h.

◆ operator==() [41/57]

constexpr bool daw::operator== ( std::uint64_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 397 of file daw_uint_types.h.

◆ operator==() [42/57]

constexpr bool daw::operator== ( std::uint64_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 392 of file daw_uint_types.h.

◆ operator==() [43/57]

constexpr bool daw::operator== ( std::uint64_t  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 387 of file daw_uint_types.h.

◆ operator==() [44/57]

constexpr bool daw::operator== ( std::uint64_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 402 of file daw_uint_types.h.

◆ operator==() [45/57]

constexpr bool daw::operator== ( std::uint8_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2846 of file daw_uint_types.h.

◆ operator==() [46/57]

template<typename CharT >
constexpr bool daw::operator== ( string_split_iterator< CharT > const lhs,
string_split_iterator< CharT > const rhs 
)
constexprnoexcept

Definition at line 102 of file daw_string_split_range.h.

◆ operator==() [47/57]

template<typename T , typename U >
constexpr bool daw::operator== ( T const value,
optional< U > const opt 
)
constexpr

Definition at line 390 of file daw_optional.h.

◆ operator==() [48/57]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator== ( typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1093 of file daw_bounded_string.h.

◆ operator==() [49/57]

constexpr bool daw::operator== ( UInt16  lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 1287 of file daw_uint_types.h.

◆ operator==() [50/57]

constexpr bool daw::operator== ( UInt32  lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 976 of file daw_uint_types.h.

◆ operator==() [51/57]

constexpr bool daw::operator== ( UInt64  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 367 of file daw_uint_types.h.

◆ operator==() [52/57]

constexpr bool daw::operator== ( UInt64  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 377 of file daw_uint_types.h.

◆ operator==() [53/57]

constexpr bool daw::operator== ( UInt64  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 372 of file daw_uint_types.h.

◆ operator==() [54/57]

constexpr bool daw::operator== ( UInt64  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 382 of file daw_uint_types.h.

◆ operator==() [55/57]

constexpr bool daw::operator== ( UInt8  lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2840 of file daw_uint_types.h.

◆ operator==() [56/57]

template<typename T , typename D0 , typename D1 = D0>
constexpr bool daw::operator== ( unique_ptr< T, D0 > const lhs,
unique_ptr< T, D1 > const rhs 
)
constexprnoexcept

Definition at line 431 of file daw_unique_ptr.h.

◆ operator==() [57/57]

template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_equality< T, U >, std::nullptr_t > = nullptr>
constexpr bool daw::operator== ( value_ptr< T > const lhs,
value_ptr< U > const rhs 
)
constexprnoexcept

Definition at line 245 of file daw_value_ptr.h.

◆ operator>() [1/41]

template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool daw::operator> ( basic_bounded_string< CharT, CapacityL > const lhs,
basic_bounded_string< CharT, CapacityR > const rhs 
)
constexprnoexcept

Definition at line 825 of file daw_bounded_string.h.

◆ operator>() [2/41]

template<typename CharT , size_t Capacity, size_t N>
constexpr bool daw::operator> ( CharT const (&)  lhs[N],
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1224 of file daw_bounded_string.h.

◆ operator>() [3/41]

constexpr bool daw::operator> ( copiable_unique_ptr< T1, D1 > const lhs,
copiable_unique_ptr< T2, D2 > const rhs 
)
constexprnoexcept

Definition at line 226 of file daw_copiable_unique_ptr.h.

◆ operator>() [4/41]

constexpr bool daw::operator> ( copiable_unique_ptr< T1, D1 > const lhs,
std::nullptr_t   
)
constexprnoexcept

Definition at line 232 of file daw_copiable_unique_ptr.h.

◆ operator>() [5/41]

template<typename CharT , size_t Capacity, size_t N>
constexpr bool daw::operator> ( daw::basic_bounded_string< CharT, Capacity > const lhs,
CharT const (&)  rhs[N] 
)
constexprnoexcept

Definition at line 1176 of file daw_bounded_string.h.

◆ operator>() [6/41]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator> ( daw::basic_bounded_string< CharT, Capacity > const lhs,
daw::sv1::basic_string_view< CharT >  rhs 
)
constexprnoexcept

Definition at line 875 of file daw_bounded_string.h.

◆ operator>() [7/41]

template<typename CharT , size_t Capacity>
bool daw::operator> ( daw::basic_bounded_string< CharT, Capacity > const lhs,
std::basic_string< CharT > const rhs 
)
noexcept

Definition at line 971 of file daw_bounded_string.h.

◆ operator>() [8/41]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator> ( daw::basic_bounded_string< CharT, Capacity > const lhs,
typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  rhs 
)
constexprnoexcept

Definition at line 1074 of file daw_bounded_string.h.

◆ operator>() [9/41]

template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool daw::operator> ( daw::not_null< Lhs > const lhs,
daw::not_null< Rhs > const rhs 
)
constexprnoexcept

Definition at line 343 of file daw_not_null.h.

◆ operator>() [10/41]

template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool daw::operator> ( daw::not_null< Pointer > const lhs,
Pointer const rhs 
)
constexprnoexcept

Definition at line 350 of file daw_not_null.h.

◆ operator>() [11/41]

template<typename T >
bool daw::operator> ( daw::optional_poly< T > const lhs,
daw::optional_poly< T > const rhs 
)

Definition at line 230 of file daw_optional_poly.h.

◆ operator>() [12/41]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator> ( daw::sv1::basic_string_view< CharT > const lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 925 of file daw_bounded_string.h.

◆ operator>() [13/41]

Definition at line 268 of file daw_hash_table.h.

◆ operator>() [14/41]

template<typename T , typename U >
bool daw::operator> ( heap_value< T > const lhs,
heap_value< U > const rhs 
)

Definition at line 144 of file deprecated/daw_heap_value.h.

◆ operator>() [15/41]

template<typename T >
constexpr bool daw::operator> ( indexed_iterator< T > const lhs,
indexed_iterator< T > const rhs 
)
constexprnoexcept

Definition at line 322 of file daw_indexed_iterator.h.

◆ operator>() [16/41]

template<typename T , typename U >
constexpr bool daw::operator> ( natural_t< T > const lhs,
natural_t< U > const rhs 
)
constexprnoexcept

Definition at line 205 of file daw_natural.h.

◆ operator>() [17/41]

template<typename T , typename U >
constexpr bool daw::operator> ( optional< T > const lhs,
optional< U > const rhs 
)
constexpr

Definition at line 297 of file daw_optional.h.

◆ operator>() [18/41]

template<typename T >
constexpr bool daw::operator> ( optional< T > const opt,
std::nullopt_t   
)
constexprnoexcept

Definition at line 360 of file daw_optional.h.

◆ operator>() [19/41]

template<typename T , typename U >
constexpr bool daw::operator> ( optional< T > const opt,
U const value 
)
constexpr

Definition at line 446 of file daw_optional.h.

◆ operator>() [20/41]

template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool daw::operator> ( Pointer const lhs,
daw::not_null< Pointer > const rhs 
)
constexprnoexcept

Definition at line 356 of file daw_not_null.h.

◆ operator>() [21/41]

template<typename T >
bool daw::operator> ( Reference< T > const lhs,
Reference< T > const rhs 
)

Definition at line 61 of file daw_reference.h.

◆ operator>() [22/41]

Definition at line 168 of file daw_reverse_iterator.h.

◆ operator>() [23/41]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator> ( std::basic_string< CharT > const lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1020 of file daw_bounded_string.h.

◆ operator>() [24/41]

template<typename T >
constexpr bool daw::operator> ( std::nullopt_t  ,
optional< T > const  
)
constexprnoexcept

Definition at line 365 of file daw_optional.h.

◆ operator>() [25/41]

constexpr bool daw::operator> ( std::nullptr_t  ,
copiable_unique_ptr< T2, D2 > const rhs 
)
constexprnoexcept

Definition at line 239 of file daw_copiable_unique_ptr.h.

◆ operator>() [26/41]

constexpr bool daw::operator> ( std::uint16_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1317 of file daw_uint_types.h.

◆ operator>() [27/41]

constexpr bool daw::operator> ( std::uint64_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 447 of file daw_uint_types.h.

◆ operator>() [28/41]

constexpr bool daw::operator> ( std::uint64_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 442 of file daw_uint_types.h.

◆ operator>() [29/41]

constexpr bool daw::operator> ( std::uint64_t  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 437 of file daw_uint_types.h.

◆ operator>() [30/41]

constexpr bool daw::operator> ( std::uint64_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 452 of file daw_uint_types.h.

◆ operator>() [31/41]

constexpr bool daw::operator> ( std::uint8_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2762 of file daw_uint_types.h.

◆ operator>() [32/41]

template<typename T , typename U >
constexpr bool daw::operator> ( T const value,
optional< U > const opt 
)
constexpr

Definition at line 454 of file daw_optional.h.

◆ operator>() [33/41]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator> ( typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1125 of file daw_bounded_string.h.

◆ operator>() [34/41]

constexpr bool daw::operator> ( UInt16  lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 1311 of file daw_uint_types.h.

◆ operator>() [35/41]

constexpr bool daw::operator> ( UInt16  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 427 of file daw_uint_types.h.

◆ operator>() [36/41]

constexpr bool daw::operator> ( UInt32  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 422 of file daw_uint_types.h.

◆ operator>() [37/41]

constexpr bool daw::operator> ( UInt64  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 417 of file daw_uint_types.h.

◆ operator>() [38/41]

constexpr bool daw::operator> ( UInt8  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 432 of file daw_uint_types.h.

◆ operator>() [39/41]

constexpr bool daw::operator> ( UInt8  lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2756 of file daw_uint_types.h.

◆ operator>() [40/41]

template<typename T , typename D0 , typename D1 = D0>
constexpr bool daw::operator> ( unique_ptr< T, D0 > const lhs,
unique_ptr< T, D1 > const rhs 
)
constexprnoexcept

Definition at line 455 of file daw_unique_ptr.h.

◆ operator>() [41/41]

template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_greater< T, U >, std::nullptr_t > = nullptr>
constexpr bool daw::operator> ( value_ptr< T > const lhs,
value_ptr< U > const rhs 
)
constexprnoexcept

Definition at line 264 of file daw_value_ptr.h.

◆ operator>=() [1/43]

template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool daw::operator>= ( basic_bounded_string< CharT, CapacityL > const lhs,
basic_bounded_string< CharT, CapacityR > const rhs 
)
constexprnoexcept

Definition at line 833 of file daw_bounded_string.h.

◆ operator>=() [2/43]

template<typename CharT , size_t Capacity, size_t N>
constexpr bool daw::operator>= ( CharT const (&)  lhs[N],
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1231 of file daw_bounded_string.h.

◆ operator>=() [3/43]

template<typename T , typename U >
constexpr bool daw::operator>= ( const T &  value,
const optional< U > &  opt 
)
constexpr

Definition at line 470 of file daw_optional.h.

◆ operator>=() [4/43]

constexpr bool daw::operator>= ( copiable_unique_ptr< T1, D1 > const lhs,
copiable_unique_ptr< T2, D2 > const rhs 
)
constexprnoexcept

Definition at line 246 of file daw_copiable_unique_ptr.h.

◆ operator>=() [5/43]

constexpr bool daw::operator>= ( copiable_unique_ptr< T1, D1 > const lhs,
std::nullptr_t   
)
constexprnoexcept

Definition at line 252 of file daw_copiable_unique_ptr.h.

◆ operator>=() [6/43]

template<typename CharT , size_t Capacity, size_t N>
constexpr bool daw::operator>= ( daw::basic_bounded_string< CharT, Capacity > const lhs,
CharT const (&)  rhs[N] 
)
constexprnoexcept

Definition at line 1184 of file daw_bounded_string.h.

◆ operator>=() [7/43]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator>= ( daw::basic_bounded_string< CharT, Capacity > const lhs,
daw::sv1::basic_string_view< CharT >  rhs 
)
constexprnoexcept

Definition at line 883 of file daw_bounded_string.h.

◆ operator>=() [8/43]

template<typename CharT , size_t Capacity>
bool daw::operator>= ( daw::basic_bounded_string< CharT, Capacity > const lhs,
std::basic_string< CharT > const rhs 
)
noexcept

Definition at line 978 of file daw_bounded_string.h.

◆ operator>=() [9/43]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator>= ( daw::basic_bounded_string< CharT, Capacity lhs,
typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  rhs 
)
constexprnoexcept

Definition at line 1083 of file daw_bounded_string.h.

◆ operator>=() [10/43]

template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool daw::operator>= ( daw::not_null< Lhs > const lhs,
daw::not_null< Rhs > const rhs 
)
constexprnoexcept

Definition at line 362 of file daw_not_null.h.

◆ operator>=() [11/43]

template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool daw::operator>= ( daw::not_null< Pointer > const lhs,
Pointer const rhs 
)
constexprnoexcept

Definition at line 369 of file daw_not_null.h.

◆ operator>=() [12/43]

template<typename T >
bool daw::operator>= ( daw::optional_poly< T > const lhs,
daw::optional_poly< T > const rhs 
)

Definition at line 242 of file daw_optional_poly.h.

◆ operator>=() [13/43]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator>= ( daw::sv1::basic_string_view< CharT > const lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 933 of file daw_bounded_string.h.

◆ operator>=() [14/43]

Definition at line 274 of file daw_hash_table.h.

◆ operator>=() [15/43]

template<typename T , typename U >
bool daw::operator>= ( heap_value< T > const lhs,
heap_value< U > const rhs 
)

Definition at line 134 of file deprecated/daw_heap_value.h.

◆ operator>=() [16/43]

template<typename T >
constexpr bool daw::operator>= ( indexed_iterator< T > const lhs,
indexed_iterator< T > const rhs 
)
constexprnoexcept

Definition at line 334 of file daw_indexed_iterator.h.

◆ operator>=() [17/43]

template<typename T , typename U >
constexpr bool daw::operator>= ( natural_t< T > const lhs,
natural_t< U > const rhs 
)
constexprnoexcept

Definition at line 211 of file daw_natural.h.

◆ operator>=() [18/43]

template<typename T >
constexpr bool daw::operator>= ( optional< T > const ,
std::nullopt_t   
)
constexprnoexcept

Definition at line 371 of file daw_optional.h.

◆ operator>=() [19/43]

template<typename T , typename U >
constexpr bool daw::operator>= ( optional< T > const lhs,
optional< U > const rhs 
)
constexpr

Definition at line 308 of file daw_optional.h.

◆ operator>=() [20/43]

template<typename T , typename U >
constexpr bool daw::operator>= ( optional< T > const opt,
U const value 
)
constexpr

Definition at line 462 of file daw_optional.h.

◆ operator>=() [21/43]

template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool daw::operator>= ( Pointer const lhs,
daw::not_null< Pointer > const rhs 
)
constexprnoexcept

Definition at line 375 of file daw_not_null.h.

◆ operator>=() [22/43]

template<typename T >
bool daw::operator>= ( Reference< T > const lhs,
Reference< T > const rhs 
)

Definition at line 66 of file daw_reference.h.

◆ operator>=() [23/43]

Definition at line 174 of file daw_reverse_iterator.h.

◆ operator>=() [24/43]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator>= ( std::basic_string< CharT > const lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1028 of file daw_bounded_string.h.

◆ operator>=() [25/43]

template<typename T >
constexpr bool daw::operator>= ( std::nullopt_t  ,
optional< T > const opt 
)
constexprnoexcept

Definition at line 377 of file daw_optional.h.

◆ operator>=() [26/43]

constexpr bool daw::operator>= ( std::nullptr_t  ,
copiable_unique_ptr< T2, D2 > const rhs 
)
constexprnoexcept

Definition at line 259 of file daw_copiable_unique_ptr.h.

◆ operator>=() [27/43]

constexpr bool daw::operator>= ( std::uint16_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1329 of file daw_uint_types.h.

◆ operator>=() [28/43]

constexpr bool daw::operator>= ( std::uint32_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 910 of file daw_uint_types.h.

◆ operator>=() [29/43]

constexpr bool daw::operator>= ( std::uint64_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 487 of file daw_uint_types.h.

◆ operator>=() [30/43]

constexpr bool daw::operator>= ( std::uint64_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 482 of file daw_uint_types.h.

◆ operator>=() [31/43]

constexpr bool daw::operator>= ( std::uint64_t  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 477 of file daw_uint_types.h.

◆ operator>=() [32/43]

constexpr bool daw::operator>= ( std::uint64_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 492 of file daw_uint_types.h.

◆ operator>=() [33/43]

constexpr bool daw::operator>= ( std::uint8_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2774 of file daw_uint_types.h.

◆ operator>=() [34/43]

template<typename CharT , size_t Capacity>
constexpr bool daw::operator>= ( typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  lhs,
daw::basic_bounded_string< CharT, Capacity > const rhs 
)
constexprnoexcept

Definition at line 1133 of file daw_bounded_string.h.

◆ operator>=() [35/43]

constexpr bool daw::operator>= ( UInt16  lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 1323 of file daw_uint_types.h.

◆ operator>=() [36/43]

constexpr bool daw::operator>= ( UInt16  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 467 of file daw_uint_types.h.

◆ operator>=() [37/43]

constexpr bool daw::operator>= ( UInt32  lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 904 of file daw_uint_types.h.

◆ operator>=() [38/43]

constexpr bool daw::operator>= ( UInt32  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 462 of file daw_uint_types.h.

◆ operator>=() [39/43]

constexpr bool daw::operator>= ( UInt64  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 457 of file daw_uint_types.h.

◆ operator>=() [40/43]

constexpr bool daw::operator>= ( UInt8  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 472 of file daw_uint_types.h.

◆ operator>=() [41/43]

constexpr bool daw::operator>= ( UInt8  lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2768 of file daw_uint_types.h.

◆ operator>=() [42/43]

template<typename T , typename D0 , typename D1 = D0>
constexpr bool daw::operator>= ( unique_ptr< T, D0 > const lhs,
unique_ptr< T, D1 > const rhs 
)
constexprnoexcept

Definition at line 461 of file daw_unique_ptr.h.

◆ operator>=() [43/43]

template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_greater_equal< T, U >, std::nullptr_t > = nullptr>
constexpr bool daw::operator>= ( value_ptr< T > const lhs,
value_ptr< U > const rhs 
)
constexprnoexcept

Definition at line 273 of file daw_value_ptr.h.

◆ operator>>() [1/22]

constexpr std::uint16_t daw::operator>> ( std::uint16_t  b,
UInt16  shift 
)
constexprnoexcept

Definition at line 1178 of file daw_uint_types.h.

◆ operator>>() [2/22]

constexpr std::uint32_t daw::operator>> ( std::uint32_t  b,
UInt16  shift 
)
constexprnoexcept

Definition at line 805 of file daw_uint_types.h.

◆ operator>>() [3/22]

constexpr std::uint32_t daw::operator>> ( std::uint32_t  b,
UInt32  shift 
)
constexprnoexcept

Definition at line 799 of file daw_uint_types.h.

◆ operator>>() [4/22]

constexpr std::uint32_t daw::operator>> ( std::uint32_t  b,
UInt8  shift 
)
constexprnoexcept

Definition at line 811 of file daw_uint_types.h.

◆ operator>>() [5/22]

constexpr std::uint64_t daw::operator>> ( std::uint64_t  b,
UInt16  shift 
)
constexprnoexcept

Definition at line 222 of file daw_uint_types.h.

◆ operator>>() [6/22]

constexpr std::uint64_t daw::operator>> ( std::uint64_t  b,
UInt32  shift 
)
constexprnoexcept

Definition at line 217 of file daw_uint_types.h.

◆ operator>>() [7/22]

constexpr std::uint64_t daw::operator>> ( std::uint64_t  b,
UInt64  shift 
)
constexprnoexcept

Definition at line 212 of file daw_uint_types.h.

◆ operator>>() [8/22]

constexpr std::uint64_t daw::operator>> ( std::uint64_t  b,
UInt8  shift 
)
constexprnoexcept

Definition at line 227 of file daw_uint_types.h.

◆ operator>>() [9/22]

constexpr std::uint8_t daw::operator>> ( std::uint8_t  b,
UInt8  shift 
)
constexprnoexcept

Definition at line 2704 of file daw_uint_types.h.

◆ operator>>() [10/22]

constexpr UInt16 daw::operator>> ( UInt16  b,
std::uint16_t  shift 
)
constexprnoexcept

Definition at line 1165 of file daw_uint_types.h.

◆ operator>>() [11/22]

constexpr UInt16 daw::operator>> ( UInt16  b,
UInt16  shift 
)
constexprnoexcept

Definition at line 1172 of file daw_uint_types.h.

◆ operator>>() [12/22]

constexpr UInt32 daw::operator>> ( UInt32  b,
std::uint32_t  shift 
)
constexprnoexcept

Definition at line 776 of file daw_uint_types.h.

◆ operator>>() [13/22]

constexpr UInt32 daw::operator>> ( UInt32  b,
UInt16  shift 
)
constexprnoexcept

Definition at line 788 of file daw_uint_types.h.

◆ operator>>() [14/22]

constexpr UInt32 daw::operator>> ( UInt32  b,
UInt32  shift 
)
constexprnoexcept

Definition at line 783 of file daw_uint_types.h.

◆ operator>>() [15/22]

constexpr UInt32 daw::operator>> ( UInt32  b,
UInt8  shift 
)
constexprnoexcept

Definition at line 793 of file daw_uint_types.h.

◆ operator>>() [16/22]

constexpr UInt64 daw::operator>> ( UInt64  b,
std::uint64_t  shift 
)
constexprnoexcept

Definition at line 182 of file daw_uint_types.h.

◆ operator>>() [17/22]

constexpr UInt64 daw::operator>> ( UInt64  b,
UInt16  shift 
)
constexprnoexcept

Definition at line 200 of file daw_uint_types.h.

◆ operator>>() [18/22]

constexpr UInt64 daw::operator>> ( UInt64  b,
UInt32  shift 
)
constexprnoexcept

Definition at line 194 of file daw_uint_types.h.

◆ operator>>() [19/22]

constexpr UInt64 daw::operator>> ( UInt64  b,
UInt64  shift 
)
constexprnoexcept

Definition at line 188 of file daw_uint_types.h.

◆ operator>>() [20/22]

constexpr UInt64 daw::operator>> ( UInt64  b,
UInt8  shift 
)
constexprnoexcept

Definition at line 206 of file daw_uint_types.h.

◆ operator>>() [21/22]

constexpr UInt8 daw::operator>> ( UInt8  b,
std::uint8_t  shift 
)
constexprnoexcept

Definition at line 2691 of file daw_uint_types.h.

◆ operator>>() [22/22]

constexpr UInt8 daw::operator>> ( UInt8  b,
UInt8  shift 
)
constexprnoexcept

Definition at line 2698 of file daw_uint_types.h.

◆ operator>>=() [1/14]

constexpr UInt16 & daw::operator>>= ( UInt16 b,
std::uint16_t  shift 
)
constexprnoexcept

Definition at line 1117 of file daw_uint_types.h.

◆ operator>>=() [2/14]

constexpr UInt16 & daw::operator>>= ( UInt16 b,
UInt16  shift 
)
constexprnoexcept

Definition at line 1125 of file daw_uint_types.h.

◆ operator>>=() [3/14]

constexpr UInt16 & daw::operator>>= ( UInt16 b,
UInt8  shift 
)
constexprnoexcept

Definition at line 1132 of file daw_uint_types.h.

◆ operator>>=() [4/14]

constexpr UInt32 & daw::operator>>= ( UInt32 b,
std::uint32_t  shift 
)
constexprnoexcept

Definition at line 716 of file daw_uint_types.h.

◆ operator>>=() [5/14]

constexpr UInt32 & daw::operator>>= ( UInt32 b,
UInt16  shift 
)
constexprnoexcept

Definition at line 731 of file daw_uint_types.h.

◆ operator>>=() [6/14]

constexpr UInt32 & daw::operator>>= ( UInt32 b,
UInt32  shift 
)
constexprnoexcept

Definition at line 724 of file daw_uint_types.h.

◆ operator>>=() [7/14]

constexpr UInt32 & daw::operator>>= ( UInt32 b,
UInt8  shift 
)
constexprnoexcept

Definition at line 738 of file daw_uint_types.h.

◆ operator>>=() [8/14]

constexpr UInt64 & daw::operator>>= ( UInt64 b,
std::uint64_t  shift 
)
constexprnoexcept

Definition at line 97 of file daw_uint_types.h.

◆ operator>>=() [9/14]

constexpr UInt64 & daw::operator>>= ( UInt64 b,
UInt16  shift 
)
constexprnoexcept

Definition at line 118 of file daw_uint_types.h.

◆ operator>>=() [10/14]

constexpr UInt64 & daw::operator>>= ( UInt64 b,
UInt32  shift 
)
constexprnoexcept

Definition at line 111 of file daw_uint_types.h.

◆ operator>>=() [11/14]

constexpr UInt64 & daw::operator>>= ( UInt64 b,
UInt64  shift 
)
constexprnoexcept

Definition at line 104 of file daw_uint_types.h.

◆ operator>>=() [12/14]

constexpr UInt64 & daw::operator>>= ( UInt64 b,
UInt8  shift 
)
constexprnoexcept

Definition at line 125 of file daw_uint_types.h.

◆ operator>>=() [13/14]

constexpr UInt8 & daw::operator>>= ( UInt8 b,
std::uint8_t  shift 
)
constexprnoexcept

Definition at line 2656 of file daw_uint_types.h.

◆ operator>>=() [14/14]

constexpr UInt8 & daw::operator>>= ( UInt8 b,
UInt8  shift 
)
constexprnoexcept

Definition at line 2664 of file daw_uint_types.h.

◆ operator^() [1/23]

constexpr UInt16 daw::operator^ ( std::uint16_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1281 of file daw_uint_types.h.

◆ operator^() [2/23]

constexpr UInt32 daw::operator^ ( std::uint32_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 970 of file daw_uint_types.h.

◆ operator^() [3/23]

constexpr UInt64 daw::operator^ ( std::uint64_t  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 362 of file daw_uint_types.h.

◆ operator^() [4/23]

constexpr UInt8 daw::operator^ ( std::uint8_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2834 of file daw_uint_types.h.

◆ operator^() [5/23]

constexpr UInt16 daw::operator^ ( UInt16  lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 1275 of file daw_uint_types.h.

◆ operator^() [6/23]

constexpr UInt16 daw::operator^ ( UInt16  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1379 of file daw_uint_types.h.

◆ operator^() [7/23]

constexpr UInt32 daw::operator^ ( UInt16  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1065 of file daw_uint_types.h.

◆ operator^() [8/23]

constexpr UInt64 daw::operator^ ( UInt16  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 657 of file daw_uint_types.h.

◆ operator^() [9/23]

constexpr UInt16 daw::operator^ ( UInt16  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1384 of file daw_uint_types.h.

◆ operator^() [10/23]

constexpr UInt32 daw::operator^ ( UInt32  lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 964 of file daw_uint_types.h.

◆ operator^() [11/23]

constexpr UInt32 daw::operator^ ( UInt32  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1055 of file daw_uint_types.h.

◆ operator^() [12/23]

constexpr UInt32 daw::operator^ ( UInt32  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1050 of file daw_uint_types.h.

◆ operator^() [13/23]

constexpr UInt64 daw::operator^ ( UInt32  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 652 of file daw_uint_types.h.

◆ operator^() [14/23]

constexpr UInt32 daw::operator^ ( UInt32  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1060 of file daw_uint_types.h.

◆ operator^() [15/23]

constexpr UInt64 daw::operator^ ( UInt64  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 357 of file daw_uint_types.h.

◆ operator^() [16/23]

constexpr UInt64 daw::operator^ ( UInt64  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 642 of file daw_uint_types.h.

◆ operator^() [17/23]

constexpr UInt64 daw::operator^ ( UInt64  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 637 of file daw_uint_types.h.

◆ operator^() [18/23]

constexpr UInt64 daw::operator^ ( UInt64  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 632 of file daw_uint_types.h.

◆ operator^() [19/23]

constexpr UInt64 daw::operator^ ( UInt64  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 647 of file daw_uint_types.h.

◆ operator^() [20/23]

constexpr UInt8 daw::operator^ ( UInt8  lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2828 of file daw_uint_types.h.

◆ operator^() [21/23]

constexpr UInt32 daw::operator^ ( UInt8  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1070 of file daw_uint_types.h.

◆ operator^() [22/23]

constexpr UInt64 daw::operator^ ( UInt8  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 662 of file daw_uint_types.h.

◆ operator^() [23/23]

constexpr UInt8 daw::operator^ ( UInt8  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2874 of file daw_uint_types.h.

◆ operator^=() [1/14]

constexpr UInt16 & daw::operator^= ( UInt16 lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 1229 of file daw_uint_types.h.

◆ operator^=() [2/14]

constexpr UInt16 & daw::operator^= ( UInt16 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1237 of file daw_uint_types.h.

◆ operator^=() [3/14]

constexpr UInt16 & daw::operator^= ( UInt16 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1244 of file daw_uint_types.h.

◆ operator^=() [4/14]

constexpr UInt32 & daw::operator^= ( UInt32 lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 875 of file daw_uint_types.h.

◆ operator^=() [5/14]

constexpr UInt32 & daw::operator^= ( UInt32 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 890 of file daw_uint_types.h.

◆ operator^=() [6/14]

constexpr UInt32 & daw::operator^= ( UInt32 lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 883 of file daw_uint_types.h.

◆ operator^=() [7/14]

constexpr UInt32 & daw::operator^= ( UInt32 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 897 of file daw_uint_types.h.

◆ operator^=() [8/14]

constexpr UInt64 & daw::operator^= ( UInt64 lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 302 of file daw_uint_types.h.

◆ operator^=() [9/14]

constexpr UInt64 & daw::operator^= ( UInt64 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 323 of file daw_uint_types.h.

◆ operator^=() [10/14]

constexpr UInt64 & daw::operator^= ( UInt64 lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 316 of file daw_uint_types.h.

◆ operator^=() [11/14]

constexpr UInt64 & daw::operator^= ( UInt64 lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 309 of file daw_uint_types.h.

◆ operator^=() [12/14]

constexpr UInt64 & daw::operator^= ( UInt64 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 330 of file daw_uint_types.h.

◆ operator^=() [13/14]

constexpr UInt8 & daw::operator^= ( UInt8 lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2741 of file daw_uint_types.h.

◆ operator^=() [14/14]

constexpr UInt8 & daw::operator^= ( UInt8 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2749 of file daw_uint_types.h.

◆ operator|() [1/23]

constexpr UInt16 daw::operator| ( std::uint16_t  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1257 of file daw_uint_types.h.

◆ operator|() [2/23]

constexpr UInt32 daw::operator| ( std::uint32_t  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 946 of file daw_uint_types.h.

◆ operator|() [3/23]

constexpr UInt64 daw::operator| ( std::uint64_t  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 342 of file daw_uint_types.h.

◆ operator|() [4/23]

constexpr UInt8 daw::operator| ( std::uint8_t  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2810 of file daw_uint_types.h.

◆ operator|() [5/23]

constexpr UInt16 daw::operator| ( UInt16  lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 1251 of file daw_uint_types.h.

◆ operator|() [6/23]

constexpr UInt16 daw::operator| ( UInt16  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1359 of file daw_uint_types.h.

◆ operator|() [7/23]

constexpr UInt32 daw::operator| ( UInt16  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1015 of file daw_uint_types.h.

◆ operator|() [8/23]

constexpr UInt64 daw::operator| ( UInt16  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 587 of file daw_uint_types.h.

◆ operator|() [9/23]

constexpr UInt16 daw::operator| ( UInt16  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1364 of file daw_uint_types.h.

◆ operator|() [10/23]

constexpr UInt32 daw::operator| ( UInt32  lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 940 of file daw_uint_types.h.

◆ operator|() [11/23]

constexpr UInt32 daw::operator| ( UInt32  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1005 of file daw_uint_types.h.

◆ operator|() [12/23]

constexpr UInt32 daw::operator| ( UInt32  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1000 of file daw_uint_types.h.

◆ operator|() [13/23]

constexpr UInt64 daw::operator| ( UInt32  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 582 of file daw_uint_types.h.

◆ operator|() [14/23]

constexpr UInt32 daw::operator| ( UInt32  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1010 of file daw_uint_types.h.

◆ operator|() [15/23]

constexpr UInt64 daw::operator| ( UInt64  lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 337 of file daw_uint_types.h.

◆ operator|() [16/23]

constexpr UInt64 daw::operator| ( UInt64  lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 572 of file daw_uint_types.h.

◆ operator|() [17/23]

constexpr UInt64 daw::operator| ( UInt64  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 567 of file daw_uint_types.h.

◆ operator|() [18/23]

constexpr UInt64 daw::operator| ( UInt64  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 562 of file daw_uint_types.h.

◆ operator|() [19/23]

constexpr UInt64 daw::operator| ( UInt64  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 577 of file daw_uint_types.h.

◆ operator|() [20/23]

constexpr UInt8 daw::operator| ( UInt8  lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2804 of file daw_uint_types.h.

◆ operator|() [21/23]

constexpr UInt32 daw::operator| ( UInt8  lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 1020 of file daw_uint_types.h.

◆ operator|() [22/23]

constexpr UInt64 daw::operator| ( UInt8  lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 592 of file daw_uint_types.h.

◆ operator|() [23/23]

constexpr UInt8 daw::operator| ( UInt8  lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2864 of file daw_uint_types.h.

◆ operator|=() [1/14]

constexpr UInt16 & daw::operator|= ( UInt16 lhs,
std::uint16_t  rhs 
)
constexprnoexcept

Definition at line 1185 of file daw_uint_types.h.

◆ operator|=() [2/14]

constexpr UInt16 & daw::operator|= ( UInt16 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 1193 of file daw_uint_types.h.

◆ operator|=() [3/14]

constexpr UInt16 & daw::operator|= ( UInt16 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 1200 of file daw_uint_types.h.

◆ operator|=() [4/14]

constexpr UInt32 & daw::operator|= ( UInt32 lhs,
std::uint32_t  rhs 
)
constexprnoexcept

Definition at line 817 of file daw_uint_types.h.

◆ operator|=() [5/14]

constexpr UInt32 & daw::operator|= ( UInt32 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 832 of file daw_uint_types.h.

◆ operator|=() [6/14]

constexpr UInt32 & daw::operator|= ( UInt32 lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 825 of file daw_uint_types.h.

◆ operator|=() [7/14]

constexpr UInt32 & daw::operator|= ( UInt32 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 839 of file daw_uint_types.h.

◆ operator|=() [8/14]

constexpr UInt64 & daw::operator|= ( UInt64 lhs,
std::uint64_t  rhs 
)
constexprnoexcept

Definition at line 232 of file daw_uint_types.h.

◆ operator|=() [9/14]

constexpr UInt64 & daw::operator|= ( UInt64 lhs,
UInt16  rhs 
)
constexprnoexcept

Definition at line 253 of file daw_uint_types.h.

◆ operator|=() [10/14]

constexpr UInt64 & daw::operator|= ( UInt64 lhs,
UInt32  rhs 
)
constexprnoexcept

Definition at line 246 of file daw_uint_types.h.

◆ operator|=() [11/14]

constexpr UInt64 & daw::operator|= ( UInt64 lhs,
UInt64  rhs 
)
constexprnoexcept

Definition at line 239 of file daw_uint_types.h.

◆ operator|=() [12/14]

constexpr UInt64 & daw::operator|= ( UInt64 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 260 of file daw_uint_types.h.

◆ operator|=() [13/14]

constexpr UInt8 & daw::operator|= ( UInt8 lhs,
std::uint8_t  rhs 
)
constexprnoexcept

Definition at line 2711 of file daw_uint_types.h.

◆ operator|=() [14/14]

constexpr UInt8 & daw::operator|= ( UInt8 lhs,
UInt8  rhs 
)
constexprnoexcept

Definition at line 2719 of file daw_uint_types.h.

◆ operator~() [1/4]

constexpr UInt16 daw::operator~ ( UInt16  value)
constexpr

Definition at line 2441 of file daw_uint_types.h.

◆ operator~() [2/4]

constexpr UInt32 daw::operator~ ( UInt32  value)
constexpr

Definition at line 2157 of file daw_uint_types.h.

◆ operator~() [3/4]

constexpr UInt64 daw::operator~ ( UInt64  value)
constexpr

Definition at line 1773 of file daw_uint_types.h.

◆ operator~() [4/4]

constexpr UInt8 daw::operator~ ( UInt8  value)
constexpr

Definition at line 2638 of file daw_uint_types.h.

◆ or_all() [1/3]

constexpr auto daw::or_all ( )
constexprnoexcept

Definition at line 393 of file daw_utility.h.

◆ or_all() [2/3]

template<typename Value >
constexpr Value daw::or_all ( Value  value)
constexprnoexcept

Definition at line 398 of file daw_utility.h.

◆ or_all() [3/3]

template<typename Value , typename... T>
constexpr decltype(auto) daw::or_all ( Value  value,
T...  values 
)
constexprnoexcept

Definition at line 403 of file daw_utility.h.

◆ overload()

template<typename... Funcs>
daw::overload ( Funcs &&  ...) -> overload< conditional_t< std::is_class_v< daw::remove_cvref_t< Funcs > >, daw::remove_cvref_t< Funcs >, Funcs >... >

◆ pack_apply()

template<typename Function , typename... Args>
constexpr void daw::pack_apply ( std::size_t  N,
Function &&  func,
Args &&...  args 
)
constexpr

Definition at line 913 of file daw_utility.h.

◆ pack_get()

template<size_t N, std::size_t pos = 0, typename Arg , typename... Args>
constexpr decltype(auto) daw::pack_get ( Arg &&  arg,
Args &&...  args 
)
constexprnoexcept

Definition at line 881 of file daw_utility.h.

◆ pop_value() [1/2]

template<typename T , typename BitStream >
auto daw::pop_value ( BitStream bs)

Definition at line 101 of file daw_bit_stream.h.

◆ pop_value() [2/2]

template<typename T , typename BitStream >
auto daw::pop_value ( BitStream bs,
size_t  bits_needed 
)

Definition at line 81 of file daw_bit_stream.h.

◆ prev()

template<typename Iterator >
constexpr Iterator daw::prev ( Iterator  it,
ptrdiff_t  n = 1 
)
constexprnoexcept

Move iterator backward n steps, if n > 0, only defined for types that are Bidirectional.

Template Parameters
IteratorType of iterator to move backward
Parameters
itIterator to advance
nhow far to move backward
Returns
The resulting iterator of advancing it n steps

Definition at line 139 of file cpp_17_iterator.h.

◆ print() [1/3]

template<typename... Args>
DAW_ATTRIB_NOINLINE void daw::print ( FILE fout,
std::format_string< Args... >  fmt,
Args &&...  args 
)

Definition at line 21 of file daw_print.h.

◆ print() [2/3]

template<typename... Args>
DAW_ATTRIB_NOINLINE void daw::print ( std::format_string< Args... >  fmt,
Args &&...  args 
)

Definition at line 36 of file daw_print.h.

◆ print() [3/3]

template<typename... Args>
std::ostream & daw::print ( std::ostream &  os,
std::format_string< Args... >  fmt,
Args &&...  args 
)

Definition at line 22 of file daw_print_ostream.h.

◆ println() [1/4]

DAW_ATTRIB_INLINE void daw::println ( )

Definition at line 73 of file daw_print.h.

◆ println() [2/4]

template<typename... Args>
DAW_ATTRIB_NOINLINE void daw::println ( FILE f,
std::format_string< Args... >  fmt,
Args &&...  args 
)

Definition at line 47 of file daw_print.h.

◆ println() [3/4]

template<typename... Args>
DAW_ATTRIB_NOINLINE void daw::println ( std::format_string< Args... >  fmt,
Args &&...  args 
)

Definition at line 61 of file daw_print.h.

◆ println() [4/4]

template<typename... Args>
std::ostream & daw::println ( std::ostream &  os,
std::format_string< Args... >  fmt,
Args &&...  args 
)

Definition at line 33 of file daw_print_ostream.h.

◆ quick_sort()

template<typename RandomIterator , typename Compare = std::less<>>
constexpr void daw::quick_sort ( RandomIterator  f,
RandomIterator  l,
Compare  cmp = Compare{ } 
)
constexpr

Definition at line 57 of file daw_stack_quick_sort.h.

◆ randint() [1/2]

template<typename IntType >
IntType daw::randint ( )
inline

Definition at line 48 of file daw_random.h.

◆ randint() [2/2]

template<typename IntType >
IntType daw::randint ( IntType  a,
IntType  b 
)
inline

Definition at line 36 of file daw_random.h.

◆ random_fill()

template<typename IntType , typename ItValueType = IntType, typename ForwardIterator >
void daw::random_fill ( ForwardIterator  first,
ForwardIterator const  last,
IntType  a,
IntType  b 
)
inline

Definition at line 73 of file daw_random.h.

◆ read_file() [1/2]

template<typename CharT = char>
DAW_ATTRIB_NOINLINE std::optional< std::basic_string< CharT > > daw::read_file ( std::string const path)
noexcept

Definition at line 27 of file daw_read_file.h.

◆ read_file() [2/2]

std::string daw::read_file ( std::string const path,
terminate_on_read_file_error_t   
)
inlinenoexcept

Definition at line 62 of file daw_read_file.h.

◆ ref() [1/2]

template<typename T , typename = void>
auto daw::ref ( T const value)

Definition at line 76 of file daw_reference.h.

◆ ref() [2/2]

template<typename T >
auto daw::ref ( T const value)

Definition at line 71 of file daw_reference.h.

◆ repeat_n_char_end()

template<typename T = char>
constexpr auto daw::repeat_n_char_end ( )
constexprnoexcept

Definition at line 105 of file daw_repeat_n_char_iterator.h.

◆ repeat_n_char_iterator()

template<typename CharT >
daw::repeat_n_char_iterator ( size_t  ,
CharT   
) -> repeat_n_char_iterator< CharT >

◆ reseed() [1/2]

void daw::reseed ( )
inline

Definition at line 52 of file daw_random.h.

◆ reseed() [2/2]

void daw::reseed ( std::default_random_engine::result_type  value)
inline

Definition at line 56 of file daw_random.h.

◆ return_buffer()

template<typename T >
void daw::return_buffer ( T *  ptr)
inlinenoexcept

Definition at line 948 of file daw_utility.h.

◆ reverse_iterator()

template<typename Iterator >
daw::reverse_iterator ( Iterator  ) -> reverse_iterator< Iterator >

◆ reverse_topological_sorted_walk() [1/2]

template<typename T , typename Func , typename Compare = daw::graph_alg_impl::NoSort>
void daw::reverse_topological_sorted_walk ( daw::graph_t< T > &  known_deps,
Func  visitor,
Compare &&  comp = Compare{ } 
)

Definition at line 513 of file daw_graph_algorithm.h.

◆ reverse_topological_sorted_walk() [2/2]

template<typename T , typename Func , typename Compare = daw::graph_alg_impl::NoSort>
void daw::reverse_topological_sorted_walk ( daw::graph_t< T > const known_deps,
Func  visitor,
Compare &&  comp = Compare{ } 
)

Definition at line 493 of file daw_graph_algorithm.h.

◆ ring_adaptor()

template<typename T >
daw::ring_adaptor ( T const ) -> ring_adaptor< T >

◆ rotate_left() [1/8]

template<unsigned bits>
constexpr UInt16 daw::rotate_left ( UInt16  value)
constexpr

Definition at line 2446 of file daw_uint_types.h.

◆ rotate_left() [2/8]

constexpr UInt16 daw::rotate_left ( UInt16  value,
unsigned  bits 
)
constexpr

Definition at line 2452 of file daw_uint_types.h.

◆ rotate_left() [3/8]

template<unsigned bits>
constexpr UInt32 daw::rotate_left ( UInt32  value)
constexpr

Definition at line 1076 of file daw_uint_types.h.

◆ rotate_left() [4/8]

constexpr UInt32 daw::rotate_left ( UInt32  value,
unsigned  bits 
)
constexpr

Definition at line 1081 of file daw_uint_types.h.

◆ rotate_left() [5/8]

template<unsigned bits>
constexpr UInt64 daw::rotate_left ( UInt64  value)
constexpr

Definition at line 668 of file daw_uint_types.h.

◆ rotate_left() [6/8]

constexpr UInt64 daw::rotate_left ( UInt64  value,
unsigned  bits 
)
constexpr

Definition at line 673 of file daw_uint_types.h.

◆ rotate_left() [7/8]

template<unsigned bits>
constexpr UInt8 daw::rotate_left ( UInt8  value)
constexpr

Definition at line 2931 of file daw_uint_types.h.

◆ rotate_left() [8/8]

constexpr UInt8 daw::rotate_left ( UInt8  value,
unsigned  bits 
)
constexpr

Definition at line 2937 of file daw_uint_types.h.

◆ rotate_right() [1/8]

template<unsigned bits>
constexpr UInt16 daw::rotate_right ( UInt16  value)
constexpr

Definition at line 2457 of file daw_uint_types.h.

◆ rotate_right() [2/8]

constexpr UInt16 daw::rotate_right ( UInt16  value,
unsigned  bits 
)
constexpr

Definition at line 2463 of file daw_uint_types.h.

◆ rotate_right() [3/8]

template<unsigned bits>
constexpr UInt32 daw::rotate_right ( UInt32  value)
constexpr

Definition at line 1086 of file daw_uint_types.h.

◆ rotate_right() [4/8]

constexpr UInt32 daw::rotate_right ( UInt32  value,
unsigned  bits 
)
constexpr

Definition at line 1091 of file daw_uint_types.h.

◆ rotate_right() [5/8]

template<unsigned bits>
constexpr UInt64 daw::rotate_right ( UInt64  value)
constexpr

Definition at line 678 of file daw_uint_types.h.

◆ rotate_right() [6/8]

constexpr UInt64 daw::rotate_right ( UInt64  value,
unsigned  bits 
)
constexpr

Definition at line 683 of file daw_uint_types.h.

◆ rotate_right() [7/8]

template<unsigned bits>
constexpr UInt8 daw::rotate_right ( UInt8  value)
constexpr

Definition at line 2943 of file daw_uint_types.h.

◆ rotate_right() [8/8]

constexpr UInt8 daw::rotate_right ( UInt8  value,
unsigned  bits 
)
constexpr

Definition at line 2949 of file daw_uint_types.h.

◆ RunIfValid()

template<typename T >
auto daw::RunIfValid ( std::weak_ptr< T >  w_ptr)

Definition at line 354 of file daw_utility.h.

◆ safe_advance() [1/2]

template<typename Container , typename Iterator , typename Distance >
constexpr void daw::safe_advance ( Container container,
Iterator &  it,
Distance  distance 
)
constexprnoexcept

Advance Iterator within the bounds of container.

Template Parameters
ContainerContainer type who's iterators are of type Iterator
IteratorIterator pointing to members of container.
Parameters
containercontainer to set bounds on iterator
ititerator to move. It is undefined behavior if iterator is outside the range [std::begin(container), std::end(container)]
distancehow far to move

Definition at line 140 of file daw_algorithm.h.

◆ safe_advance() [2/2]

template<typename Container , typename Iterator , typename Distance >
constexpr void daw::safe_advance ( Container const container,
Iterator &  it,
Distance  distance 
)
constexprnoexcept

Advance Iterator within the bounds of container.

Template Parameters
ContainerContainer type who's iterators are of type Iterator
IteratorIterator pointing to members of container.
Parameters
containercontainer to set bounds on iterator
ititerator to move. It is undefined behavior if iterator is outside the range [std::begin(container), std::end(container)]
distancehow far to move

Definition at line 161 of file daw_algorithm.h.

◆ safe_next()

template<typename Iterator , typename Distance = size_t>
constexpr Iterator daw::safe_next ( Iterator  it,
Iterator const  last,
Distance  n = 1U 
)
constexprnoexcept

Advance iterator n steps forward but do not go past last. Undefined if it > last.

Template Parameters
IteratorType of Iterator to advance
Parameters
ititerator to advance
lastboundary for it
nnumber of steps to advance forwards
Returns
The resulting iterator advanced n steps

Definition at line 183 of file daw_algorithm.h.

◆ safe_prev()

template<typename Iterator , typename Distance >
constexpr Iterator daw::safe_prev ( Iterator  it,
Iterator  first,
Distance  n = 1 
)
constexprnoexcept

Advance iterator n steps backward but do not go past first. Undefined if it < first.

Template Parameters
IteratorType of Iterator to advance
Parameters
ititerator to advance
firstboundary for it
nnumber of steps to advance backwards
Returns
The resulting iterator advanced n steps

Definition at line 201 of file daw_algorithm.h.

◆ set_bit() [1/4]

template<unsigned N>
constexpr void daw::set_bit ( UInt16 value,
bool  state 
)
inlineconstexpr

Definition at line 2906 of file daw_uint_types.h.

◆ set_bit() [2/4]

template<unsigned N>
constexpr void daw::set_bit ( UInt32 value,
bool  state 
)
inlineconstexpr

Definition at line 2893 of file daw_uint_types.h.

◆ set_bit() [3/4]

template<unsigned N>
constexpr void daw::set_bit ( UInt64 value,
bool  state 
)
inlineconstexpr

Definition at line 2880 of file daw_uint_types.h.

◆ set_bit() [4/4]

template<unsigned N>
constexpr void daw::set_bit ( UInt8 value,
bool  state 
)
inlineconstexpr

Definition at line 2919 of file daw_uint_types.h.

◆ set_bits()

template<typename Integer , typename Bit , typename... Bits>
constexpr Integer daw::set_bits ( Integer  i,
Bit  b,
Bits...  bs 
)
constexprnoexcept

set bits at positions specified by b,bs...

Definition at line 78 of file daw_bit.h.

◆ show_benchmark()

template<typename Func >
DAW_ATTRIB_NOINLINE void daw::show_benchmark ( size_t  data_size_bytes,
std::string const title,
Func &&  func,
size_t  data_prec = 1,
size_t  time_prec = 0,
size_t  item_count = 1 
)

Definition at line 117 of file daw_benchmark.h.

◆ shuffle()

void daw::shuffle ( RandomIterator  first,
RandomIterator  last 
)
inline

Definition at line 61 of file daw_random.h.

◆ signbit()

template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool daw::signbit ( t)
constexpr

Definition at line 102 of file daw_int_cmp.h.

◆ simple_array()

template<typename T , typename... Ts>
daw::simple_array ( T &&  ,
Ts &&  ... 
) -> simple_array< T, sizeof...(Ts)+1 >

◆ siphash24()

template<typename Byte >
constexpr uint64_t daw::siphash24 ( Byte const first,
size_t  sz,
Byte const *const  key 
)
constexpr

Definition at line 85 of file daw_sip_hash.h.

◆ size()

template<typename Container >
constexpr auto daw::size ( Container const c) -> decltype( c.size( ) )
constexprnoexcept

Definition at line 117 of file cpp_17.h.

◆ skip_bits()

template<typename BitStream >
void daw::skip_bits ( BitStream bs,
size_t  bits_needed 
)

Definition at line 106 of file daw_bit_stream.h.

◆ skip_bytes()

template<typename BitStream >
void daw::skip_bytes ( BitStream bs,
size_t  bytes_needed 
)

Definition at line 116 of file daw_bit_stream.h.

◆ skip_until() [1/2]

void daw::skip_until ( BitStream bs,
TestValue const v 
)

Definition at line 137 of file daw_bit_stream.h.

◆ skip_until() [2/2]

void daw::skip_until ( BitStream bs,
TestValue const v,
size_t  bit_count 
)

Definition at line 121 of file daw_bit_stream.h.

◆ sort()

template<typename RandomIterator , typename Compare = std::less<>>
constexpr void daw::sort ( RandomIterator  first,
RandomIterator  last,
Compare &&  comp = Compare{ } 
)
constexprnoexcept

Definition at line 563 of file daw_sort_n.h.

◆ sort_16()

template<typename RandomIterator , typename Compare = std::less<>>
constexpr void daw::sort_16 ( RandomIterator  first,
Compare &&  comp = Compare{ } 
)
constexprnoexcept

Definition at line 275 of file daw_sort_n.h.

◆ sort_3()

template<typename RandomIterator , typename Compare = std::less<>>
constexpr void daw::sort_3 ( RandomIterator  first,
Compare &&  comp = Compare{ } 
)
constexprnoexcept

Definition at line 339 of file daw_sort_n.h.

◆ sort_32()

template<typename RandomIterator , typename Compare = std::less<>>
constexpr void daw::sort_32 ( RandomIterator  first,
Compare &&  comp = Compare{ } 
)
constexprnoexcept

Definition at line 59 of file daw_sort_n.h.

◆ sort_4()

template<typename RandomIterator , typename Compare = std::less<>>
constexpr void daw::sort_4 ( RandomIterator  first,
Compare &&  comp = Compare{ } 
)
constexprnoexcept

Definition at line 347 of file daw_sort_n.h.

◆ sort_5()

template<typename RandomIterator , typename Compare = std::less<>>
constexpr void daw::sort_5 ( RandomIterator  first,
Compare &&  comp = Compare{ } 
)
constexprnoexcept

Definition at line 357 of file daw_sort_n.h.

◆ sort_6()

template<typename RandomIterator , typename Compare = std::less<>>
constexpr void daw::sort_6 ( RandomIterator  first,
Compare &&  comp = Compare{ } 
)
constexprnoexcept

Definition at line 370 of file daw_sort_n.h.

◆ sort_7()

template<typename RandomIterator , typename Compare = std::less<>>
constexpr void daw::sort_7 ( RandomIterator  first,
Compare &&  comp = Compare{ } 
)
constexprnoexcept

Definition at line 387 of file daw_sort_n.h.

◆ sort_8()

template<typename RandomIterator , typename Compare = std::less<>>
constexpr void daw::sort_8 ( RandomIterator  first,
Compare &&  comp = Compare{ } 
)
constexprnoexcept

Definition at line 408 of file daw_sort_n.h.

◆ sort_to() [1/2]

template<typename ForwardIterator , typename RandomOutputIterator , typename Compare = std::less<>, std::enable_if_t< std::is_integral_v< typename std::iterator_traits< ForwardIterator >::value_type >, std::nullptr_t > = nullptr>
constexpr RandomOutputIterator daw::sort_to ( ForwardIterator  first_in,
ForwardIterator  last_in,
RandomOutputIterator  first_out,
Compare &&  comp = Compare{ } 
)
constexpr

Definition at line 793 of file daw_sort_n.h.

◆ sort_to() [2/2]

template<typename InputIterator , typename RandomOutputIterator , typename Compare = std::less<>, std::enable_if_t< not std::is_integral_v< typename std::iterator_traits< InputIterator >::value_type >, std::nullptr_t > = nullptr>
constexpr RandomOutputIterator daw::sort_to ( InputIterator  first_in,
InputIterator  last_in,
RandomOutputIterator  first_out,
Compare &&  comp = Compare{ } 
)
constexpr

Definition at line 738 of file daw_sort_n.h.

◆ span() [1/10]

template<typename Container >
daw::span ( Container ) -> span< std::remove_reference_t< decltype(*std::data(std::declval< Container >()))> >

◆ span() [2/10]

template<typename Container >
daw::span ( Container const ) -> span< DAW_TYPEOF(*std::data(std::declval< Container >())) const >

◆ span() [3/10]

template<typename T >
daw::span ( T *  ,
size_t   
) -> span< T >

◆ span() [4/10]

template<typename T >
daw::span ( T *  ,
T *   
) -> span< T >

◆ span() [5/10]

template<typename T >
daw::span ( T *  ,
T const  
) -> span< T >

◆ span() [6/10]

template<typename T , size_t N>
daw::span ( T   const(&)[N]) -> span< T const >

◆ span() [7/10]

template<typename T >
daw::span ( T const ,
size_t   
) -> span< T const >

◆ span() [8/10]

template<typename T >
daw::span ( T const ,
T *   
) -> span< T const >

◆ span() [9/10]

template<typename T >
daw::span ( T const ,
T const  
) -> span< T const >

◆ span() [10/10]

template<typename T , size_t N>
daw::span ( T(&)  [N]) -> span< T >

◆ split() [1/6]

template<typename CharT , size_t Capacity, size_t N>
auto daw::split ( daw::basic_bounded_string< CharT, Capacity > &&  str,
CharT const (&)  delemiter[N] 
)
delete

◆ split() [2/6]

template<typename CharT , size_t Capacity>
auto daw::split ( daw::basic_bounded_string< CharT, Capacity > &&  str,
CharT const  delemiter 
)
delete

◆ split() [3/6]

template<typename CharT , size_t Capacity, size_t N>
auto daw::split ( daw::basic_bounded_string< CharT, Capacity > const str,
CharT const (&)  delemiter[N] 
)

Definition at line 1323 of file daw_bounded_string.h.

◆ split() [4/6]

template<typename CharT , size_t Capacity>
auto daw::split ( daw::basic_bounded_string< CharT, Capacity > const str,
CharT const  delemiter 
)

Definition at line 1311 of file daw_bounded_string.h.

◆ split() [5/6]

template<typename CharT , size_t N, typename UnaryPredicate >
auto daw::split ( daw::basic_bounded_string< CharT, N > &&  str,
UnaryPredicate  pred 
)
delete

◆ split() [6/6]

template<typename CharT , size_t N, typename UnaryPredicate >
auto daw::split ( daw::basic_bounded_string< CharT, N > const str,
UnaryPredicate  pred 
)

Definition at line 1295 of file daw_bounded_string.h.

◆ split_args()

template<std::size_t StartN, std::size_t EndN, typename... Args, std::enable_if_t<(sizeof...(Args) >=EndN), std::nullptr_t > = nullptr>
constexpr auto daw::split_args ( std::tuple< Args... >  args)
constexpr

Definition at line 41 of file daw_bind_args_at.h.

◆ split_args_impl()

template<std::size_t StartN, typename... Args, std::size_t... Is, std::enable_if_t<(sizeof...(Args) >=(sizeof...(Is)+StartN)), std::nullptr_t > = nullptr>
constexpr auto daw::split_args_impl ( std::tuple< Args... > &&  args,
std::index_sequence< Is... >   
)
constexpr

Definition at line 28 of file daw_bind_args_at.h.

◆ split_string() [1/6]

template<typename CharT , typename Bounds = daw::sv1::default_string_view_bounds_type, size_t N, size_t M>
constexpr string_split_range< CharT > daw::split_string ( CharT const (&)  str[N],
CharT const (&)  delemiter[M] 
)
constexprnoexcept

Definition at line 201 of file daw_string_split_range.h.

◆ split_string() [2/6]

template<typename CharT >
constexpr string_split_range< CharT > daw::split_string ( daw::sv1::basic_string_view< CharT >  str,
daw::sv1::basic_string_view< CharT >  delemiter 
)
constexprnoexcept

Definition at line 170 of file daw_string_split_range.h.

◆ split_string() [3/6]

template<typename CharT , typename Bounds , std::ptrdiff_t Ex, size_t N>
constexpr string_split_range< CharT > daw::split_string ( daw::sv1::basic_string_view< CharT, Bounds, Ex str,
CharT const (&)  delemiter[N] 
)
constexprnoexcept

Definition at line 178 of file daw_string_split_range.h.

◆ split_string() [4/6]

template<typename CharT , daw::sv2::string_view_bounds_type Bounds, std::ptrdiff_t Ex, size_t N>
constexpr string_split_range< CharT > daw::split_string ( daw::sv2::basic_string_view< CharT, Bounds str,
CharT const (&)  delemiter[N] 
)
constexprnoexcept

Definition at line 190 of file daw_string_split_range.h.

◆ split_string() [5/6]

template<typename CharT >
string_split_range< CharT > daw::split_string ( std::basic_string< CharT > const str,
daw::sv1::basic_string_view< CharT >  delemiter 
)
noexcept

Definition at line 153 of file daw_string_split_range.h.

◆ split_string() [6/6]

template<typename CharT >
string_split_range< CharT > daw::split_string ( std::basic_string< CharT > const str,
std::basic_string< CharT > &  delemiter 
)
noexcept

Definition at line 161 of file daw_string_split_range.h.

◆ string_concat()

template<typename... Strings>
std::string daw::string_concat ( std::string  arg,
Strings &&...  strings 
)
inline

Definition at line 150 of file daw_string_concat.h.

◆ string_split_iterator()

◆ string_split_range()

◆ swap() [1/14]

template<typename CharT , size_t N>
constexpr void daw::swap ( basic_bounded_string< CharT, N > &  lhs,
basic_bounded_string< CharT, N > &  rhs 
)
constexprnoexcept

Definition at line 748 of file daw_bounded_string.h.

◆ swap() [2/14]

template<typename T , size_t N>
constexpr void daw::swap ( carray< T, N > &  lhs,
carray< T, N > &  rhs 
)
constexprnoexcept

Definition at line 226 of file daw_carray.h.

◆ swap() [3/14]

template<class T1 , class T2 >
constexpr void daw::swap ( compressed_pair< T1, T2 > &  x,
compressed_pair< T1, T2 > &  y 
)
constexprnoexcept

Definition at line 167 of file compressed_pair.h.

◆ swap() [4/14]

template<typename T , typename Deleter >
constexpr void daw::swap ( copiable_unique_ptr< T, Deleter > &  lhs,
copiable_unique_ptr< T, Deleter > &  rhs 
)
constexprnoexcept

Definition at line 128 of file daw_copiable_unique_ptr.h.

◆ swap() [5/14]

template<typename... Args>
void daw::swap ( CString< Args... > &  lhs,
CString< Args... > &  rhs 
)
noexcept

Definition at line 165 of file daw_cstring.h.

◆ swap() [6/14]

template<typename T >
constexpr void daw::swap ( daw::heap_array< T > &  lhs,
daw::heap_array< T > &  rhs 
)
constexprnoexcept

Definition at line 231 of file daw_heap_array.h.

◆ swap() [7/14]

template<typename T >
void daw::swap ( daw::optional_poly< T > &  lhs,
daw::optional_poly< T > &  rhs 
)
noexcept

Definition at line 170 of file daw_optional_poly.h.

◆ swap() [8/14]

template<typename T >
void daw::swap ( hash_table< T > &  lhs,
hash_table< T > &  rhs 
)
noexcept

Definition at line 676 of file daw_hash_table.h.

◆ swap() [9/14]

template<typename T >
void daw::swap ( hash_table_item_iterator< T > &  lhs,
hash_table_item_iterator< T > &  rhs 
)
noexcept

Definition at line 292 of file daw_hash_table.h.

◆ swap() [10/14]

template<typename T >
void daw::swap ( heap_value< T > &  lhs,
heap_value< T > &  rhs 
)
noexcept

Definition at line 119 of file deprecated/daw_heap_value.h.

◆ swap() [11/14]

template<typename T , typename D >
constexpr void daw::swap ( rc_ptr< T, D > &  lhs,
rc_ptr< T, D > &  rhs 
)
constexpr

Definition at line 401 of file daw_ref_counted_pointer.h.

◆ swap() [12/14]

template<class T , class Allocator >
constexpr void daw::swap ( split_buffer< T, Allocator > &  x,
split_buffer< T, Allocator > &  y 
)
inlineconstexprnoexcept

Definition at line 535 of file split_buffer.h.

◆ swap() [13/14]

template<typename T >
constexpr void daw::swap ( value_ptr< T > &  lhs,
value_ptr< T > &  rhs 
)
constexprnoexcept

Definition at line 216 of file daw_value_ptr.h.

◆ swap() [14/14]

template<typename T , typename Allocator >
constexpr void daw::swap ( vector< T, Allocator > &  x,
vector< T, Allocator > &  y 
)
constexprnoexcept

Definition at line 1289 of file vector.h.

◆ swap_ranges()

constexpr ForwardIterator2 daw::swap_ranges ( ForwardIterator1  first1,
ForwardIterator1  last1,
ForwardIterator2  first2 
)
constexprnoexcept

Definition at line 78 of file daw_swap.h.

◆ take()

template<typename T , std::enable_if_t< std::is_default_constructible_v< T >, std::nullptr_t > = nullptr>
constexpr T daw::take ( T &  value)
constexprnoexcept

Definition at line 31 of file daw_take.h.

◆ tie()

template<typename... Ts>
constexpr tuple< Ts &... > daw::tie ( Ts &...  ts)
constexprnoexcept

Definition at line 230 of file daw_tuple.h.

◆ to_address() [1/2]

template<typename T >
constexpr T * daw::to_address ( T *  p)
constexprnoexcept

Definition at line 78 of file cpp_20.h.

◆ to_address() [2/2]

template<typename T >
constexpr auto daw::to_address ( T const p)
constexprnoexcept

Definition at line 84 of file cpp_20.h.

◆ to_array()

template<typename T , std::size_t N>
constexpr std::array< std::remove_cv_t< T >, N > daw::to_array ( T(&)  a[N])
constexpr

Definition at line 31 of file daw_array.h.

◆ to_array_of()

template<typename To , typename From >
auto daw::to_array_of ( From &&  from)
noexcept

Definition at line 789 of file daw_utility.h.

◆ to_big_endian()

template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>
constexpr T daw::to_big_endian ( value)
constexprnoexcept

Definition at line 124 of file daw_endian.h.

◆ to_little_endian()

template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>
constexpr T daw::to_little_endian ( value)
constexprnoexcept

Definition at line 114 of file daw_endian.h.

◆ to_native_endian()

template<endian SourceEndian, typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>
constexpr T daw::to_native_endian ( value)
constexprnoexcept

Definition at line 144 of file daw_endian.h.

◆ to_os_string_int()

template<typename CharT , typename OutputIterator , typename Integer , typename Traits = daw::impl::char_traits<CharT>, std::enable_if_t< can_to_os_string_int_v< daw::remove_cvref_t< Integer > >, std::nullptr_t > = nullptr>
constexpr OutputIterator daw::to_os_string_int ( OutputIterator  it,
Integer  value 
)
constexpr

Definition at line 229 of file daw_int_to_iterator.h.

◆ to_reference_vector()

template<typename Iterator >
auto daw::to_reference_vector ( Iterator  first,
Iterator  last 
)

Definition at line 81 of file daw_reference.h.

◆ to_string() [1/2]

template<typename Char >
std::string daw::to_string ( CString< Char > const str)

Definition at line 171 of file daw_cstring.h.

◆ to_string() [2/2]

template<size_t BitWidth>
std::string daw::to_string ( static_bitset< BitWidth > const bs)
inline

Definition at line 531 of file daw_static_bitset.h.

◆ to_uint16()

template<typename Number >
constexpr UInt16 daw::to_uint16 ( Number  num)
constexpr

Definition at line 43 of file daw_uint_types.h.

◆ to_uint16_buffer()

template<typename CharT , std::enable_if_t<(sizeof(CharT)==1), std::nullptr_t > = nullptr>
constexpr UInt16 daw::to_uint16_buffer ( CharT const ptr)
constexprnoexcept

Definition at line 3038 of file daw_uint_types.h.

◆ to_uint32()

template<typename Number >
constexpr UInt32 daw::to_uint32 ( Number  num)
constexpr

Definition at line 37 of file daw_uint_types.h.

◆ to_uint32_buffer()

template<typename CharT , std::enable_if_t<(sizeof(CharT)==1), std::nullptr_t > = nullptr>
constexpr UInt32 daw::to_uint32_buffer ( CharT const ptr)
constexprnoexcept

Definition at line 3023 of file daw_uint_types.h.

◆ to_uint64()

template<typename Number >
constexpr UInt64 daw::to_uint64 ( Number  num)
constexpr

Definition at line 31 of file daw_uint_types.h.

◆ to_uint64_buffer()

template<typename CharT , std::enable_if_t<(sizeof(CharT)==1), std::nullptr_t > = nullptr>
constexpr UInt64 daw::to_uint64_buffer ( CharT const ptr)
constexprnoexcept

Definition at line 3000 of file daw_uint_types.h.

◆ to_uint8()

template<typename Number >
constexpr UInt8 daw::to_uint8 ( Number  num)
constexpr

Definition at line 49 of file daw_uint_types.h.

◆ to_underlying()

template<typename Enum , std::enable_if_t< std::is_enum_v< Enum >, std::nullptr_t > = nullptr>
constexpr auto daw::to_underlying ( Enum  e)
constexpr

Definition at line 16 of file daw_to_underlying_type.h.

◆ topological_sorted_walk() [1/2]

template<typename T , typename Function , typename Compare = daw::graph_alg_impl::NoSort>
void daw::topological_sorted_walk ( daw::graph_t< T > &  graph,
Function &&  func,
Compare  comp = Compare{ } 
)

Definition at line 245 of file daw_graph_algorithm.h.

◆ topological_sorted_walk() [2/2]

template<typename T , typename Function , typename Compare = daw::graph_alg_impl::NoSort>
void daw::topological_sorted_walk ( daw::graph_t< T > const graph,
Function &&  func,
Compare  comp = Compare{ } 
)

Definition at line 231 of file daw_graph_algorithm.h.

◆ try_get() [1/2]

template<typename Map , typename Key >
constexpr auto daw::try_get ( Map &  container,
Key &&  k 
)
constexpr

Definition at line 53 of file daw_algorithm.h.

◆ try_get() [2/2]

template<typename Map , typename Key >
constexpr auto daw::try_get ( Map const container,
Key &&  k 
)
constexpr

Definition at line 63 of file daw_algorithm.h.

◆ tuple()

template<typename... Ts>
daw::tuple ( Ts...  ) -> tuple< Ts... >

◆ tuple2()

template<typename... Ts>
daw::tuple2 ( Ts...  ) -> tuple2< Ts... >

◆ tuple2_cat() [1/3]

constexpr tuple2 daw::tuple2_cat ( )
constexpr

Definition at line 208 of file daw_tuple2.h.

◆ tuple2_cat() [2/3]

template<typename T0 , typename T1 , typename... Tps>
constexpr auto daw::tuple2_cat ( T0 &&  t0,
T1 &&  t1,
Tps &&...  tps 
)
constexpr

Definition at line 218 of file daw_tuple2.h.

◆ tuple2_cat() [3/3]

template<typename Tuple >
constexpr tuple2 daw::tuple2_cat ( Tuple &&  tp)
constexpr

Definition at line 213 of file daw_tuple2.h.

◆ unset_bits()

template<typename Integer , typename Bit , typename... Bits>
constexpr Integer daw::unset_bits ( Integer  i,
Bit  b,
Bits...  bs 
)
constexprnoexcept

set bits at positions specified by b,bs...

Definition at line 87 of file daw_bit.h.

◆ value_from_chars() [1/4]

template<typename To >
constexpr uint16_t daw::value_from_chars ( unsigned char const ptr,
std::integral_constant< size_t, sizeof(uint16_t)>   
)
constexprnoexcept

Definition at line 733 of file daw_utility.h.

◆ value_from_chars() [2/4]

template<typename To >
constexpr uint32_t daw::value_from_chars ( unsigned char const ptr,
std::integral_constant< size_t, sizeof(uint32_t)>   
)
constexprnoexcept

Definition at line 743 of file daw_utility.h.

◆ value_from_chars() [3/4]

template<typename To >
constexpr uint64_t daw::value_from_chars ( unsigned char const ptr,
std::integral_constant< size_t, sizeof(uint64_t)>   
)
constexprnoexcept

Definition at line 757 of file daw_utility.h.

◆ value_from_chars() [4/4]

template<typename To >
constexpr uint8_t daw::value_from_chars ( unsigned char const ptr,
std::integral_constant< size_t, sizeof(uint8_t)>   
)
constexprnoexcept

Definition at line 726 of file daw_utility.h.

◆ value_is()

template<typename T >
constexpr auto daw::value_is ( T &&  value) -> daw::utility_details::value_is_utility_details< std::remove_reference_t<decltype( value )>>
constexpr

Definition at line 822 of file daw_utility.h.

◆ values_from_stream() [1/2]

template<typename... Args, typename Stream >
decltype(auto) daw::values_from_stream ( Stream &&  s,
daw::string_view  delemiter 
)

Extract specified argument types from a stream of character data.

Template Parameters
ArgsTypes of expected data to find in string
StreamText stream type
Parameters
stext stream to extract values from
delemitersplit what string arguments on
Returns
A tuple of values of the types specified in Args

Definition at line 531 of file daw_parse_to.h.

◆ values_from_stream() [2/2]

template<typename... Args, typename Stream , typename Splitter , std::enable_if_t<(not parse_to_impl::has_str_member_v< Stream > and std::is_invocable_v< Splitter, daw::string_view >), std::nullptr_t > = nullptr>
decltype(auto) daw::values_from_stream ( Stream &&  s,
Splitter &&  splitter 
)

Extract specified argument types from a stream of character data.

Template Parameters
ArgsTypes of expected data to find in string
StreamText stream type that does not have a str( ) method
SplitterA predicate that will return true on the string parts to split on
Parameters
streamtext stream to extract values from
splitterFunction to split string into arguments
Returns
A tuple of values of the types specified in Args
Template Parameters
ArgsTypes of expected data to find in string
StreamText stream type, like stringstream, that has a str( ) method
SplitterA predicate that will return true on the string parts to split on
Parameters
stext stream to extract values from
splitterFunction to split string into arguments
Returns
A tuple of values of the types specified in Args

Definition at line 497 of file daw_parse_to.h.

◆ variant_cast() [1/3]

template<typename T , typename... Args>
constexpr T daw::variant_cast ( std::variant< Args... > &&  var)
constexpr

Definition at line 74 of file daw_variant_cast.h.

◆ variant_cast() [2/3]

template<typename T , typename... Args>
constexpr T daw::variant_cast ( std::variant< Args... > &  var)
constexpr

Definition at line 60 of file daw_variant_cast.h.

◆ variant_cast() [3/3]

template<typename T , typename... Args>
constexpr T daw::variant_cast ( std::variant< Args... > const var)
constexpr

Definition at line 67 of file daw_variant_cast.h.

◆ vector() [1/2]

template<input_iterator InputIterator>
daw::vector ( InputIterator  ,
InputIterator   
) -> vector< iter_value_type< InputIterator >, std::allocator< iter_value_type< InputIterator > > >

◆ vector() [2/2]

template<input_iterator InputIterator, Allocators Alloc>
daw::vector ( InputIterator  ,
InputIterator  ,
Alloc   
) -> vector< iter_value_type< InputIterator >, Alloc >

◆ Vector()

template<typename T , std::size_t N>
daw::Vector ( T   const(&)[N]) -> Vector< T >

◆ view()

template<typename BidirectionalIterator >
daw::view ( BidirectionalIterator  ,
BidirectionalIterator   
) -> view< BidirectionalIterator >

◆ visit() [1/2]

template<typename Variant , typename... Visitors>
constexpr decltype(auto) daw::visit ( Variant &&  var,
Visitors &&...  visitors 
)
constexpr

Definition at line 386 of file daw_visit.h.

◆ visit() [2/2]

template<typename Result , typename Variant , typename... Visitors>
constexpr Result daw::visit ( Variant &&  var,
Visitors &&...  visitors 
)
constexpr

Definition at line 401 of file daw_visit.h.

◆ visit_nt() [1/2]

template<typename Variant , typename... Visitors>
constexpr decltype(auto) daw::visit_nt ( Variant &&  var,
Visitors &&...  visitors 
)
constexpr

Definition at line 373 of file daw_visit.h.

◆ visit_nt() [2/2]

template<typename Result , typename Variant , typename... Visitors>
constexpr Result daw::visit_nt ( Variant &&  var,
Visitors &&...  visitors 
)
constexpr

Definition at line 414 of file daw_visit.h.

◆ vprint() [1/2]

template<typename... Args>
DAW_ATTRIB_NOINLINE void daw::vprint ( FILE fout,
std::string_view  fmt,
Args &&...  args 
)

Definition at line 28 of file daw_print.h.

◆ vprint() [2/2]

template<typename... Args>
DAW_ATTRIB_NOINLINE void daw::vprint ( std::string_view  fmt,
Args &&...  args 
)

Definition at line 42 of file daw_print.h.

◆ vprintln() [1/2]

template<typename... Args>
DAW_ATTRIB_NOINLINE void daw::vprintln ( FILE f,
std::string  fmt,
Args &&...  args 
)

Definition at line 54 of file daw_print.h.

◆ vprintln() [2/2]

template<typename... Args>
DAW_ATTRIB_NOINLINE void daw::vprintln ( std::string  fmt,
Args &&...  args 
)

Definition at line 68 of file daw_print.h.

◆ zip_container()

template<typename... Containers>
daw::zip_container ( Containers &&  ...) -> zip_container< Containers... >

◆ zip_iterator()

template<typename... Iterators>
daw::zip_iterator ( Iterators...  ) -> zip_iterator< Iterators... >

Variable Documentation

◆ all_true_v

template<bool... values>
constexpr bool daw::all_true_v = ( values and ... )
inlineconstexpr

Definition at line 43 of file cpp_17.h.

◆ always_false_v

template<typename... Ts>
constexpr bool daw::always_false_v = always_false<Ts...>::value
inlineconstexpr

Definition at line 20 of file daw_always_false.h.

◆ any_of

template<auto needle, auto... needles>
constexpr any_of_t<decltype( needle ), needle, needles...> daw::any_of { }
inlinestaticconstexpr

A predicate value used in the find based routine to return true when the element is one of the specified characters.

Definition at line 38 of file daw_view_tags.h.

◆ any_true_v

template<bool... values>
constexpr bool daw::any_true_v = ( values or ... )
inlineconstexpr

Definition at line 49 of file cpp_17.h.

◆ bit_count_v

template<typename T >
constexpr std::size_t daw::bit_count_v = sizeof( T ) * CHAR_BIT
inlineconstexpr

Definition at line 16 of file daw_bit_count.h.

◆ bsizeof

template<typename T >
constexpr std::size_t const daw::bsizeof
inlineconstexpr
Initial value:
=
bit_count_v<daw::remove_cvref_t<T>>

Definition at line 941 of file daw_traits.h.

◆ can_call_v

template<size_t N, typename Invokable , typename TpArgs , typename... Args>
constexpr bool daw::can_call_v
inlineconstexpr
Initial value:

Definition at line 83 of file daw_bind_args_at.h.

◆ can_constant_evaluate_v

template<DAW_CXEVAL_FTYPE F>
constexpr bool daw::can_constant_evaluate_v
inlineconstexpr
Initial value:
=
can_constant_evaluate<F>::value

Definition at line 74 of file daw_can_constant_evaluate.h.

◆ can_construct_a_v

template<typename T , typename... Args>
constexpr bool daw::can_construct_a_v
inlineconstexpr
Initial value:
=
is_detected_v<construct_details::can_construct_a_detect, T, Args...>
constexpr bool is_detected_v

Definition at line 92 of file daw_construct_a.h.

◆ can_potentially_constant_construct_v

template<typename T , typename... Args>
constexpr bool daw::can_potentially_constant_construct_v
inlineconstexpr
Initial value:
=
typename conditional_t<(std::is_default_constructible_v< Args > and ...), can_cxeval_impl::can_potentially_constant_construct_impl< T, Args... >, daw::traits::identity< std::false_type > >::type can_potentially_constant_construct

Definition at line 92 of file daw_can_constant_evaluate.h.

◆ can_to_os_string_int_v

template<typename Integer >
constexpr bool daw::can_to_os_string_int_v
inlineconstexpr
Initial value:
=
not std::is_same_v<bool, daw::remove_cvref_t<Integer>>,
not std::is_floating_point_v<daw::remove_cvref_t<Integer>>,
not daw::traits::is_character_v<Integer>>

Definition at line 218 of file daw_int_to_iterator.h.

◆ conjunction_v

template<typename... Ts>
constexpr bool daw::conjunction_v
inlineconstexpr
Initial value:
=
( static_cast<bool>( Ts::value ) and ... )

Definition at line 33 of file cpp_17.h.

◆ constant_v

template<decltype(auto) Value>
constexpr auto daw::constant_v = constant<Value>{ }
inlineconstexpr

Definition at line 37 of file daw_constant.h.

◆ construct_a

template<typename T >
constexpr construct_a_t<T> daw::construct_a = construct_a_t<T>{ }
inlineconstexpr

Definition at line 82 of file daw_construct_a.h.

◆ construct_emplace

template<typename T = void>
constexpr construct_emplace_t<T> daw::construct_emplace { }
inlineconstexpr

Definition at line 89 of file daw_poly_value.h.

◆ construct_for_overwrite

constexpr construct_for_overwrite_t daw::construct_for_overwrite { }
inlineconstexpr

Definition at line 25 of file daw_fixed_array.h.

◆ contract_failure_handler

constinit thread_local daw::function_ref<void( )> daw::contract_failure_handler = default_contract_failure
static

Definition at line 36 of file daw_contract.h.

◆ deduced_false_v

template<typename... >
constexpr bool daw::deduced_false_v = false
inlineconstexpr

Definition at line 935 of file daw_traits.h.

◆ dependent_false_v

template<typename... >
constexpr bool daw::dependent_false_v = false
inlineconstexpr

Definition at line 13 of file daw_dependent_false.h.

◆ describe_v

template<typename T >
constexpr daw::string_view daw::describe_v = impl::describe_impl<T>( )
inlineconstexpr

Definition at line 49 of file daw_describe.h.

◆ digits

template<typename T >
constexpr auto daw::digits = numeric_limits<T>::digits
inlineconstexpr

Definition at line 243 of file daw_arith_traits.h.

◆ digits10

template<typename T >
constexpr auto daw::digits10 = numeric_limits<T>::digits10
inlineconstexpr

Definition at line 240 of file daw_arith_traits.h.

◆ discard

constexpr auto daw::discard = discard_t{ }
inlineconstexpr

Definition at line 20 of file daw_view_tags.h.

◆ disjunction_v

template<typename... Ts>
constexpr bool daw::disjunction_v
inlineconstexpr
Initial value:
=
( static_cast<bool>( Ts::value ) or ... )

Definition at line 157 of file cpp_17.h.

◆ do_resize_and_overwrite

constexpr auto daw::do_resize_and_overwrite = do_resize_and_overwrite_t{ }
inlineconstexpr

Definition at line 95 of file vector.h.

◆ dont_clip_to_bounds

constexpr auto daw::dont_clip_to_bounds = dont_clip_to_bounds_t{ }
inlineconstexpr

Definition at line 23 of file daw_view_tags.h.

◆ DynamicExtent

constexpr auto daw::DynamicExtent = max_value<std::size_t>
inlineconstexpr

Definition at line 30 of file daw_container_traits.h.

◆ fmt_binary

constexpr bitset_impl::fmt_binary_t const daw::fmt_binary { }
inlineconstexpr

Definition at line 103 of file daw_static_bitset.h.

◆ fmt_decimal

constexpr bitset_impl::fmt_decimal_t const daw::fmt_decimal { }
inlineconstexpr

Definition at line 105 of file daw_static_bitset.h.

◆ fmt_hex

constexpr bitset_impl::fmt_hex_t const daw::fmt_hex { }
inlineconstexpr

Definition at line 104 of file daw_static_bitset.h.

◆ has_kv_mapping_v

template<typename Container >
constexpr bool daw::has_kv_mapping_v
inlineconstexpr
Initial value:
= requires {
typename std::remove_cvref_t<Container>::key_type;
typename std::remove_cvref_t<Container>::mapped_type;
}

Specifies that Container has type alias members key_type and mapped_type.

Definition at line 145 of file daw_concepts.h.

◆ has_slow_distance_v

template<typename T >
constexpr bool daw::has_slow_distance_v
inlineconstexpr
Initial value:
= requires {
typename T::slow_distance;
}

Definition at line 107 of file vector.h.

◆ index_constant_v

template<std::size_t N>
constexpr index_constant<N> daw::index_constant_v = index_constant<N>{ }
inlineconstexpr

Definition at line 850 of file daw_traits.h.

◆ is_any_of_v

template<auto Needle, auto... Haystack>
constexpr bool daw::is_any_of_v = ( ( Needle == Haystack ) or ... )
inlineconstexpr

Definition at line 13 of file daw_is_any_of.h.

◆ is_arithmetic_v

template<typename T >
constexpr bool daw::is_arithmetic_v
inlineconstexpr
Initial value:
=
is_number_v<T> or std::is_enum_v<T> or

Definition at line 80 of file daw_arith_traits.h.

◆ is_ascii_alpha

constexpr auto daw::is_ascii_alpha = is_ascii_alpha_t{ }
inlineconstexpr

Definition at line 43 of file daw_ascii.h.

◆ is_ascii_alphanum

constexpr auto daw::is_ascii_alphanum = is_ascii_alphanum_t{ }
inlineconstexpr

Definition at line 55 of file daw_ascii.h.

◆ is_ascii_digit

constexpr auto daw::is_ascii_digit = is_ascii_digit_t{ }
inlineconstexpr

Definition at line 29 of file daw_ascii.h.

◆ is_ascii_printable

constexpr auto daw::is_ascii_printable = is_ascii_printable_t{ }
inlineconstexpr

Definition at line 67 of file daw_ascii.h.

◆ is_bounded_graph_node_v

template<typename T >
constexpr bool daw::is_bounded_graph_node_v = false
inlineconstexpr

Definition at line 180 of file daw_bounded_graph.h.

◆ is_bounded_graph_node_v< bounded_graph_node_t< T, MaxVerticesPerNode, Hash > >

Initial value:
=
true

Definition at line 374 of file daw_bounded_graph.h.

◆ is_bounded_graph_node_v< const_graph_node_t< T, MaxVerticesPerNode, Hash > >

template<typename T , size_t MaxVerticesPerNode, typename Hash >
constexpr bool daw::is_bounded_graph_node_v< const_graph_node_t< T, MaxVerticesPerNode, Hash > >
inlineconstexpr
Initial value:
=
true

Definition at line 264 of file daw_bounded_graph.h.

◆ is_complete_type_v

template<typename T >
constexpr bool daw::is_complete_type_v
inlineconstexpr
Initial value:
=
decltype( is_complete_details::is_complete_test(
std::declval<T *>( ) ) ){ }

Definition at line 909 of file daw_traits.h.

◆ is_daw_span_v

template<typename T >
constexpr bool const daw::is_daw_span_v = is_daw_span_t<T>::value
inlineconstexpr

Definition at line 35 of file daw_span.h.

◆ is_deduced_type_v

template<typename T >
constexpr bool daw::is_deduced_type_v = false
inlineconstexpr

Definition at line 23 of file daw_deduced_type.h.

◆ is_deduced_type_v< deduced_type >

template<>
constexpr bool daw::is_deduced_type_v< deduced_type > = true
inlineconstexpr

Definition at line 26 of file daw_deduced_type.h.

◆ is_detected_convertible_v

template<typename To , template< typename... > typename Op, typename... Args>
constexpr bool daw::is_detected_convertible_v
inlineconstexpr
Initial value:
=
is_detected_convertible<To, Op, Args...>::value
std::is_convertible< detected_t< Op, Args... >, To > is_detected_convertible

Definition at line 129 of file daw_is_detected.h.

◆ is_detected_exact_v

template<typename Expected , template< typename... > typename Op, typename... Args>
constexpr bool daw::is_detected_exact_v
inlineconstexpr
Initial value:
=
daw::is_same_v<Expected, detected_t<Op, Args...>>
typename is_detect_details::detector< nonesuch< Op, Args... >, void, Op, Args... >::type detected_t
constexpr bool is_same_v

Definition at line 116 of file daw_is_detected.h.

◆ is_detected_v

template<template< typename... > typename Op, typename... Args>
constexpr bool daw::is_detected_v
inlineconstexpr
Initial value:
=
is_detect_details::detector_v<Op, is_detect_details::pack_t<Args...>>

Definition at line 102 of file daw_is_detected.h.

◆ is_empty_tuple_v

template<typename Tuple >
constexpr bool daw::is_empty_tuple_v = ( tuple_size_v<Tuple> == 0 )
inlineconstexpr

Definition at line 505 of file daw_tuple_helper.h.

◆ is_floating_point_v

template<typename T >
constexpr bool daw::is_floating_point_v
inlineconstexpr
Initial value:

Definition at line 36 of file daw_arith_traits.h.

◆ is_graph_node_v

template<typename >
constexpr bool daw::is_graph_node_v = false
inlineconstexpr

Definition at line 157 of file daw_graph.h.

◆ is_graph_node_v< const_graph_node_t< T > >

template<typename T >
constexpr bool daw::is_graph_node_v< const_graph_node_t< T > > = true
inlineconstexpr

Definition at line 238 of file daw_graph.h.

◆ is_graph_node_v< graph_node_t< T > >

template<typename T >
constexpr bool daw::is_graph_node_v< graph_node_t< T > > = true
inlineconstexpr

Definition at line 341 of file daw_graph.h.

◆ is_integral_v

template<typename T >
constexpr bool daw::is_integral_v = daw::numeric_limits<T>::is_integer
inlineconstexpr

Definition at line 27 of file daw_arith_traits.h.

◆ is_move_insertable_v

template<typename Alloc , typename = void>
constexpr bool daw::is_move_insertable_v
inlineconstexpr
Initial value:
=
std::is_move_constructible_v<typename Alloc::value_type>

Definition at line 392 of file daw_concepts.h.

◆ is_nonesuch_v

template<typename >
constexpr bool daw::is_nonesuch_v = false
inlineconstexpr

Definition at line 30 of file daw_is_detected.h.

◆ is_nonesuch_v< nonesuch< Op, Args... > >

template<template< class... > class Op, class... Args>
constexpr bool daw::is_nonesuch_v< nonesuch< Op, Args... > > = true
inlineconstexpr

Definition at line 33 of file daw_is_detected.h.

◆ is_nothrow_callable_v

template<size_t N, typename Invokable , typename TpArgs , typename... Args>
constexpr bool daw::is_nothrow_callable_v
inlineconstexpr
Initial value:
= noexcept( std::apply(
std::declval<Invokable>( ),
std::tuple_cat( split_args<0, N>( std::forward_as_tuple(
DAW_FWD( std::declval<Args>( ) )... ) ),
std::declval<TpArgs>( ),
split_args<N, sizeof...( Args )>( std::forward_as_tuple(
DAW_FWD( std::declval<Args>( ) )... ) ) ) ) )
#define DAW_FWD(...)
Definition daw_move.h:41

Definition at line 91 of file daw_bind_args_at.h.

◆ is_nothrow_convertible_v

template<typename From , typename To >
constexpr bool daw::is_nothrow_convertible_v
inlineconstexpr
Initial value:
=
is_nothrow_convertible<From, To>::value

Definition at line 198 of file cpp_17.h.

◆ is_number_v

template<typename T >
constexpr bool daw::is_number_v
inlineconstexpr
Initial value:
=
is_integral_v<T> or is_floating_point_v<T>

Definition at line 47 of file daw_arith_traits.h.

◆ is_reference_wrapper_v

template<typename >
constexpr bool daw::is_reference_wrapper_v< std::reference_wrapper< T > > = false
inlineconstexpr

Definition at line 98 of file cpp_17.h.

◆ is_same_size_v

template<typename T , std::size_t BitSize>
constexpr bool daw::is_same_size_v = is_same_size<T, BitSize>::value
inlineconstexpr

Definition at line 199 of file daw_arith_traits.h.

◆ is_same_v

template<typename T , typename U >
constexpr bool daw::is_same_v = false
inlineconstexpr

Definition at line 15 of file daw_traits_is_same.h.

◆ is_same_v< T, T >

template<typename T >
constexpr bool daw::is_same_v< T, T > = true
inlineconstexpr

Definition at line 18 of file daw_traits_is_same.h.

◆ is_signed_v

template<typename T >
constexpr bool daw::is_signed_v
inlineconstexpr
Initial value:
=

Definition at line 58 of file daw_arith_traits.h.

◆ is_specialization_of_v

template<template< typename... > typename Primary, typename T >
constexpr bool daw::is_specialization_of_v = false
inlineconstexpr

Definition at line 883 of file daw_traits.h.

◆ is_specialization_of_v< Primary, Primary< Args... > >

template<template< typename... > typename Primary, typename... Args>
constexpr bool daw::is_specialization_of_v< Primary, Primary< Args... > >
inlineconstexpr
Initial value:
=
true

Definition at line 886 of file daw_traits.h.

◆ is_swappable_v

template<typename T >
constexpr bool daw::is_swappable_v = std::is_swappable_v<T>
inlineconstexpr

Definition at line 123 of file cpp_17.h.

◆ is_system_integral_v

template<typename T >
constexpr bool daw::is_system_integral_v = is_system_integral<T>::value
inlineconstexpr

Definition at line 193 of file daw_arith_traits.h.

◆ is_tuple2_v

template<typename >
constexpr bool daw::is_tuple2_v = false
inlineconstexpr

Definition at line 99 of file daw_tuple2.h.

◆ is_tuple2_v< tuple2< Ts... > >

template<typename... Ts>
constexpr bool daw::is_tuple2_v< tuple2< Ts... > > = true
inlineconstexpr

Definition at line 102 of file daw_tuple2.h.

◆ is_tuple_like_v

template<typename Tp , typename = void>
constexpr bool daw::is_tuple_like_v = false
inlineconstexpr

Definition at line 956 of file daw_traits.h.

◆ is_tuple_v

template<typename >
constexpr bool daw::is_tuple_v< std::tuple< Args... > > = false
inlineconstexpr

Definition at line 16 of file daw_tuple_traits.h.

◆ is_unbounded_array_v

template<typename T >
constexpr bool daw::is_unbounded_array_v = false
inlineconstexpr

Definition at line 51 of file cpp_20.h.

◆ is_unbounded_array_v< T[]>

template<typename T >
constexpr bool daw::is_unbounded_array_v< T[]> = true
inlineconstexpr

Definition at line 54 of file cpp_20.h.

◆ is_unsigned_v

template<typename T >
constexpr bool daw::is_unsigned_v
inlineconstexpr
Initial value:
=
is_integral_v<T> and not daw::numeric_limits<T>::is_signed

Definition at line 69 of file daw_arith_traits.h.

◆ is_visitable_v

template<typename Value , typename... Visitors>
constexpr bool daw::is_visitable_v
inlineconstexpr
Initial value:
=
( std::is_invocable_v<Visitors, Value> or ... )

Definition at line 421 of file daw_visit.h.

◆ lift

template<auto fp>
constexpr overload_details::lift_t<fp> daw::lift
inlineconstexpr
Initial value:
=
overload_details::lift_t<fp>{ }

Definition at line 73 of file daw_overload.h.

◆ lowest_value

template<typename T >
constexpr auto daw::lowest_value = numeric_limits<T>::lowest( )
inlineconstexpr

Definition at line 234 of file daw_arith_traits.h.

◆ mask_from_lsb16

template<unsigned N>
constexpr UInt16 daw::mask_from_lsb16
inlineconstexpr
Initial value:
= [] {
static_assert( N <= 16 );
if constexpr( N == 0 ) {
return UInt16( );
} else {
auto const One = ~to_uint16( 1U );
return ~( One << ( N - 1 ) );
}
}( )

Definition at line 2977 of file daw_uint_types.h.

◆ mask_from_lsb32

template<unsigned N>
constexpr UInt32 daw::mask_from_lsb32
inlineconstexpr
Initial value:
= [] {
static_assert( N <= 32 );
if constexpr( N == 0 ) {
return UInt32( );
} else {
auto const One = ~to_uint32( 1U );
return ~( One << ( N - 1 ) );
}
}( )

Definition at line 2966 of file daw_uint_types.h.

◆ mask_from_lsb64

template<unsigned N>
constexpr UInt64 daw::mask_from_lsb64
inlineconstexpr
Initial value:
= [] {
static_assert( N <= 64 );
if constexpr( N == 0 ) {
return UInt64( );
} else {
auto const One = ~to_uint64( 1U );
return ~( One << ( N - 1 ) );
}
}( )

Definition at line 2955 of file daw_uint_types.h.

◆ mask_from_lsb8

template<unsigned N>
constexpr UInt8 daw::mask_from_lsb8
inlineconstexpr
Initial value:
= [] {
static_assert( N <= 8 );
if constexpr( N == 0 ) {
return UInt8( );
} else {
auto const One = ~to_uint8( 1U );
return ~( One << ( N - 1 ) );
}
}( )

Definition at line 2988 of file daw_uint_types.h.

◆ max_digits10

template<typename T >
constexpr auto daw::max_digits10 = numeric_limits<T>::max_digits10
inlineconstexpr

Definition at line 237 of file daw_arith_traits.h.

◆ max_value

template<typename T >
constexpr auto daw::max_value = numeric_limits<T>::max( )
inlineconstexpr

Definition at line 228 of file daw_arith_traits.h.

◆ min_value

template<typename T >
constexpr auto daw::min_value = numeric_limits<T>::min( )
inlineconstexpr

Definition at line 231 of file daw_arith_traits.h.

◆ never_null

constexpr never_null_t daw::never_null = never_null_t{ }
inlineconstexpr

Definition at line 24 of file daw_not_null.h.

◆ nodiscard

constexpr auto daw::nodiscard = nodiscard_t{ }
inlineconstexpr

Definition at line 15 of file daw_view_tags.h.

◆ none_of

template<auto needle, auto... needles>
constexpr none_of_t<decltype( needle ), needle, needles...> daw::none_of { }
inlinestaticconstexpr

Definition at line 80 of file daw_view_tags.h.

◆ not_null_null_value

template<typename T >
constexpr T daw::not_null_null_value = T{ }
inlineconstexpr

Definition at line 27 of file daw_not_null.h.

◆ not_null_null_value< T * >

template<typename T >
constexpr T* daw::not_null_null_value< T * > = nullptr
inlineconstexpr

Definition at line 30 of file daw_not_null.h.

◆ nullopt

constexpr std::nullopt_t daw::nullopt = std::nullopt
inlineconstexpr

Definition at line 20 of file daw_optional.h.

◆ pack_index_of_v

template<typename T , typename... Ts>
constexpr auto daw::pack_index_of_v
inlineconstexpr
Initial value:
= [] {
auto result = sizeof...( Ts );
auto pos = std::size_t( -1 );
std::size_t expander[]{
( (void)++pos, std::is_same_v<Ts, T> ? ( result = pos ) : pos )... };
return result;
}( )
expander(Ts...) -> expander< Ts... >

Definition at line 627 of file daw_utility.h.

◆ pack_size_v

template<typename Pack >
constexpr auto daw::pack_size_v = deleted<Pack>
inlineconstexpr

Definition at line 32 of file daw_pack_element.h.

◆ pack_size_v< Pack< Ts... > >

template<template< typename... > typename Pack, typename... Ts>
constexpr std::size_t daw::pack_size_v< Pack< Ts... > > = sizeof...( Ts )
inlineconstexpr

Definition at line 35 of file daw_pack_element.h.

◆ param_pack_index_of_v

template<typename T , typename >
constexpr auto daw::param_pack_index_of_v = deleted<T>
inlineconstexpr

Definition at line 642 of file daw_utility.h.

◆ param_pack_index_of_v< Pack< Ts... >, T >

template<template< typename... > typename Pack, typename... Ts, typename T >
constexpr std::size_t daw::param_pack_index_of_v< Pack< Ts... >, T >
inlineconstexpr
Initial value:
=
pack_index_of_v<T, Ts...>

Definition at line 645 of file daw_utility.h.

◆ reset_on_take

template<typename T >
constexpr bool daw::reset_on_take = true
inlineconstexpr

Definition at line 26 of file daw_take.h.

◆ sized_for_overwrite

constexpr sized_for_overwrite_t daw::sized_for_overwrite
inlineconstexpr
Initial value:
=
sized_for_overwrite_t{ }

Definition at line 252 of file daw_vector.h.

◆ tag

template<typename... Args>
constexpr tag_t<Args...> daw::tag = tag_t<Args...>{ }
constexpr

Definition at line 656 of file daw_utility.h.

◆ take_ownership

constexpr take_ownership_t daw::take_ownership { }
inlineconstexpr

Definition at line 28 of file daw_fixed_array.h.

◆ template_arg

template<typename T >
constexpr template_param<T> daw::template_arg = template_param<T>{ }
inlineconstexpr

Definition at line 866 of file daw_traits.h.

◆ template_args

template<typename... Ts>
constexpr template_params<Ts...> daw::template_args
inlineconstexpr
Initial value:
=
template_params<Ts...>{ }

Definition at line 862 of file daw_traits.h.

◆ template_vals

template<auto... vals>
constexpr template_vals_t<vals...> daw::template_vals
inlineconstexpr
Initial value:
=
template_vals_t<vals...>{ }

Definition at line 872 of file daw_traits.h.

◆ terminate_on_read_file_error

constexpr auto daw::terminate_on_read_file_error
inlineconstexpr
Initial value:
=
terminate_on_read_file_error_t{ }

Definition at line 59 of file daw_read_file.h.

◆ to_lower_ascii

constexpr auto daw::to_lower_ascii = to_lower_ascii_t{ }
inlineconstexpr

Definition at line 97 of file daw_ascii.h.

◆ to_upper_ascii

constexpr auto daw::to_upper_ascii = to_upper_ascii_t{ }
inlineconstexpr

Definition at line 82 of file daw_ascii.h.

◆ tuple2_size_v

template<typename T >
constexpr std::size_t daw::tuple2_size_v = tuple2_size<T>::value
inlinestaticconstexpr

Definition at line 167 of file daw_tuple2.h.

◆ tuple_size_v

template<typename Tuple >
constexpr size_t daw::tuple_size_v
inlineconstexpr
Initial value:
=
decltype( tuple::tuple_details::tuple_size_test(
std::declval<Tuple>( ) ) )::value

Definition at line 500 of file daw_tuple_helper.h.

◆ undefined_v

template<typename T >
constexpr auto daw::undefined_v = impl::undefind_fn_t<T>{ }
inlineconstexpr

Definition at line 35 of file daw_undefined.h.